* alias.c (mark_constant_function): Use INSN_P.
(init_alias_analysis): Likewise.
* combine.c (combine_instructions): Use INSN_P.
(can_combine_p): Likewise.
(try_combine): Likewise.
(distribute_notes): Likewise.
(distribute_links): Likewise.
* cse.c (cse_around_loop): Use INSN_P.
(invalidate_skipped_block): Likewise.
(cse_set_around_loop): Likewise.
(cse_end_of_basic_block): Likewise.
(delete_trivially_dead_insns): Likewise.
* emit-rtl.c (unshare_all_rtl_again): Use INSN_P.
(unshare_all_rtl_1): Likewise.
(next_cc0_user): Likewise.
(try_split make_insn_raw): Likewise.
(remove_unnecessary_notes): Likewise.
* final.c (shorten_branches): Use INSN_P.
(leaf_renumber_regs): Likewise.
(leaf_renumber_regs_insn): Likewise.
* flow.c (find_label_refs): Use INSN_P.
(verify_wide_reg): Likewise.
(notice_stack_pointer_modification): Likewise.
(count_or_remove_death_notes): Likewise.
(verify_flow_info): Likewise.
(clear_log_links): Likewise.
* function.c (fixup_var_refs_insns): Use INSN_P.
(compute_insns_for_mem): Likewise.
* gcse.c (alloc_gcse_mem): Use INSN_P.
(compute_sets): Likewise.
(compute_hash_table): Likewise.
(classic_gcse): Likewise.
(cprop): Likewise.
(insert_insn_end_bb): Likewise.
(delete_null_pointer_checks_1): Likewise.
* global.c (expand_preferences): Use INSN_P.
(build_insn_chain): Likewise.
* graph.c (node_data): Use INSN_P.
* haifa-sched.c (priority): Use INSN_P.
(rm_line_notes): Likewise.
(rm_other_notes): Likewise.
(find_insn_reg_weight): Likewise.
(init_target_units): Likewise.
(schedule_block): Likewise.
(compute_block_forward_dependences): Likewise.
(debug_dependencies): Likewise.
(set_priorities): Likewise.
* integrate.c (function_cannot_inline_p): Use INSN_P.
(save_parm_insns): Likewise.
(copy_insn_list): Likewise.
* jump.c (mark_all_labels): Use INSN_P.
(never_reached_warning): Likewise.
* lcm.c (optimize_mode_switching): Use INSN_P.
* local-alloc.c (validate_equiv_mem): Use INSN_P.
(memref_used_between_p): Likewise.
(update_equiv_regs): Likewise.
(block_alloc): Likewise.
(no_conflict_p): Likewise.
* loop.c (scan_loop): Use INSN_P.
(find_and_verify_loops): Likewise.
(count_loop_regs_set): Likewise.
(loop_reg_used_before_p): Likewise.
(strength_reduce): Likewise.
(recombine_givs): Likewise.
(check_dbra_loop): Likewise.
(load_mems): Likewise.
(try_copy_prop): Likewise.
* print-rtl.c (print_rtx): Use INSN_P.
* recog.c (find_single_use): Use INSN_P.
* reg-stack.c (stack_regs_mentioned): Use INSN_P.
(next_flags_user): Likewise.
(swap_rtx_condition): Likewise.
* regmove.c (mark_flags_life_zones): Use INSN_P.
(optimize_reg_copy_1): Likewise.
(optimize_reg_copy_2): Likewise.
(optimize_reg_copy_3): Likewise.
(reg_is_remote_constant_p): Likewise.
(fixup_match_2): Likewise.
(regmove_optimize): Likewise.
(fixup_match_1): Likewise.
* regrename.c (build_def_use): Use INSN_P.
(replace_reg_in_block): Likewise.
(consider_use): Likewise.
* reload.c (find_equiv_reg): Use INSN_P.
* reload1.c (reload): Use INSN_P.
(maybe_fix_stack_asms): Likewise.
(calculate_needs_all_insns): Likewise.
(reload_as_needed): Likewise.
(emit_output_reload_insns): Likewise.
(delete_address_reloads_1): Likewise.
(reload_cse_regs_1): Likewise.
(reload_combine): Likewise.
(reload_cse_move2add): Likewise.
* reorg.c (redundant_insn): Use INSN_P.
(dbr_schedule): Likewise.
* resource.c (find_dead_or_set_registers): Use INSN_P.
(mark_target_live_regs): Likewise.
* rtlanal.c (reg_used_between_p): Use INSN_P.
(reg_referenced_between_p): Likewise.
(reg_set_between_p): Likewise.
(reg_set_p): Likewise.
(single_set): Likewise.
(multiple_sets): Likewise.
(find_last_value): Likewise.
(reg_set_last): Likewise.
(find_reg_note): Likewise.
(find_regno_note): Likewise.
* sibcall.c (sequence_uses_addressof): Use INSN_P.
* simplify-rtx.c (cselib_process_insn): Use INSN_P.
* ssa.c (find_evaluations): Use INSN_P.
(rename_block): Likewise.
(rename_equivalent_regs): Likewise.
* unroll.c (loop_find_equiv_value): Use INSN_P.
(set_dominates_use): Likewise.
* varasm.c (mark_constant_pool): Use INSN_P.
(mark_constants): Likewise.
* config/alpha/alpha.c (alpha_does_function_need_gp): Use INSN_P.
(alphaev4_next_group): Likewise.
(alphaev5_next_group): Likewise.
* config/c4x/c4x.c (c4x_process_after_reload): Use INSN_P.
(c4x_rptb_rpts_p): Likewise.
* config/mips/mips.c (mips16_optimize_gp): Use INSN_P.
* config/rs6000/rs6000.c (uses_TOC): Use INSN_P.
(rs6000_adjust_priority): Likewise.
* config/sh/sh.c (sh_loop_align): Use INSN_P.
(machine_dependent_reorg): Likewise.
(split_branches): Likewise.
* config/tahoe/tahoe.c (tahoe_cmp_check): Use INSN_P.
From-SVN: r35494
+2000-08-04 Rodney Brown <RodneyBrown@pmsc.com>
+
+ * alias.c (mark_constant_function): Use INSN_P.
+ (init_alias_analysis): Likewise.
+ * combine.c (combine_instructions): Use INSN_P.
+ (can_combine_p): Likewise.
+ (try_combine): Likewise.
+ (distribute_notes): Likewise.
+ (distribute_links): Likewise.
+ * cse.c (cse_around_loop): Use INSN_P.
+ (invalidate_skipped_block): Likewise.
+ (cse_set_around_loop): Likewise.
+ (cse_end_of_basic_block): Likewise.
+ (delete_trivially_dead_insns): Likewise.
+ * emit-rtl.c (unshare_all_rtl_again): Use INSN_P.
+ (unshare_all_rtl_1): Likewise.
+ (next_cc0_user): Likewise.
+ (try_split make_insn_raw): Likewise.
+ (remove_unnecessary_notes): Likewise.
+ * final.c (shorten_branches): Use INSN_P.
+ (leaf_renumber_regs): Likewise.
+ (leaf_renumber_regs_insn): Likewise.
+ * flow.c (find_label_refs): Use INSN_P.
+ (verify_wide_reg): Likewise.
+ (notice_stack_pointer_modification): Likewise.
+ (count_or_remove_death_notes): Likewise.
+ (verify_flow_info): Likewise.
+ (clear_log_links): Likewise.
+ * function.c (fixup_var_refs_insns): Use INSN_P.
+ (compute_insns_for_mem): Likewise.
+ * gcse.c (alloc_gcse_mem): Use INSN_P.
+ (compute_sets): Likewise.
+ (compute_hash_table): Likewise.
+ (classic_gcse): Likewise.
+ (cprop): Likewise.
+ (insert_insn_end_bb): Likewise.
+ (delete_null_pointer_checks_1): Likewise.
+ * global.c (expand_preferences): Use INSN_P.
+ (build_insn_chain): Likewise.
+ * graph.c (node_data): Use INSN_P.
+ * haifa-sched.c (priority): Use INSN_P.
+ (rm_line_notes): Likewise.
+ (rm_other_notes): Likewise.
+ (find_insn_reg_weight): Likewise.
+ (init_target_units): Likewise.
+ (schedule_block): Likewise.
+ (compute_block_forward_dependences): Likewise.
+ (debug_dependencies): Likewise.
+ (set_priorities): Likewise.
+ * integrate.c (function_cannot_inline_p): Use INSN_P.
+ (save_parm_insns): Likewise.
+ (copy_insn_list): Likewise.
+ * jump.c (mark_all_labels): Use INSN_P.
+ (never_reached_warning): Likewise.
+ * lcm.c (optimize_mode_switching): Use INSN_P.
+ * local-alloc.c (validate_equiv_mem): Use INSN_P.
+ (memref_used_between_p): Likewise.
+ (update_equiv_regs): Likewise.
+ (block_alloc): Likewise.
+ (no_conflict_p): Likewise.
+ * loop.c (scan_loop): Use INSN_P.
+ (find_and_verify_loops): Likewise.
+ (count_loop_regs_set): Likewise.
+ (loop_reg_used_before_p): Likewise.
+ (strength_reduce): Likewise.
+ (recombine_givs): Likewise.
+ (check_dbra_loop): Likewise.
+ (load_mems): Likewise.
+ (try_copy_prop): Likewise.
+ * print-rtl.c (print_rtx): Use INSN_P.
+ * recog.c (find_single_use): Use INSN_P.
+ * reg-stack.c (stack_regs_mentioned): Use INSN_P.
+ (next_flags_user): Likewise.
+ (swap_rtx_condition): Likewise.
+ * regmove.c (mark_flags_life_zones): Use INSN_P.
+ (optimize_reg_copy_1): Likewise.
+ (optimize_reg_copy_2): Likewise.
+ (optimize_reg_copy_3): Likewise.
+ (reg_is_remote_constant_p): Likewise.
+ (fixup_match_2): Likewise.
+ (regmove_optimize): Likewise.
+ (fixup_match_1): Likewise.
+ * regrename.c (build_def_use): Use INSN_P.
+ (replace_reg_in_block): Likewise.
+ (consider_use): Likewise.
+ * reload.c (find_equiv_reg): Use INSN_P.
+ * reload1.c (reload): Use INSN_P.
+ (maybe_fix_stack_asms): Likewise.
+ (calculate_needs_all_insns): Likewise.
+ (reload_as_needed): Likewise.
+ (emit_output_reload_insns): Likewise.
+ (delete_address_reloads_1): Likewise.
+ (reload_cse_regs_1): Likewise.
+ (reload_combine): Likewise.
+ (reload_cse_move2add): Likewise.
+ * reorg.c (redundant_insn): Use INSN_P.
+ (dbr_schedule): Likewise.
+ * resource.c (find_dead_or_set_registers): Use INSN_P.
+ (mark_target_live_regs): Likewise.
+ * rtlanal.c (reg_used_between_p): Use INSN_P.
+ (reg_referenced_between_p): Likewise.
+ (reg_set_between_p): Likewise.
+ (reg_set_p): Likewise.
+ (single_set): Likewise.
+ (multiple_sets): Likewise.
+ (find_last_value): Likewise.
+ (reg_set_last): Likewise.
+ (find_reg_note): Likewise.
+ (find_regno_note): Likewise.
+ * sibcall.c (sequence_uses_addressof): Use INSN_P.
+ * simplify-rtx.c (cselib_process_insn): Use INSN_P.
+ * ssa.c (find_evaluations): Use INSN_P.
+ (rename_block): Likewise.
+ (rename_equivalent_regs): Likewise.
+ * unroll.c (loop_find_equiv_value): Use INSN_P.
+ (set_dominates_use): Likewise.
+ * varasm.c (mark_constant_pool): Use INSN_P.
+ (mark_constants): Likewise.
+ * config/alpha/alpha.c (alpha_does_function_need_gp): Use INSN_P.
+ (alphaev4_next_group): Likewise.
+ (alphaev5_next_group): Likewise.
+ * config/c4x/c4x.c (c4x_process_after_reload): Use INSN_P.
+ (c4x_rptb_rpts_p): Likewise.
+ * config/mips/mips.c (mips16_optimize_gp): Use INSN_P.
+ * config/rs6000/rs6000.c (uses_TOC): Use INSN_P.
+ (rs6000_adjust_priority): Likewise.
+ * config/sh/sh.c (sh_loop_align): Use INSN_P.
+ (machine_dependent_reorg): Likewise.
+ (split_branches): Likewise.
+ * config/tahoe/tahoe.c (tahoe_cmp_check): Use INSN_P.
+
Fri Aug 4 11:43:49 2000 John Wehle (john@feith.com)
* combine.c (recog_for_combine): Remove the old notes
/* Determine if this is a constant function. */
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && nonlocal_reference_p (insn))
+ if (INSN_P (insn) && nonlocal_reference_p (insn))
return;
/* Mark the function. */
/* Walk the insns adding values to the new_reg_base_value array. */
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx note, set;
subst_low_cuid = i;
subst_insn = insn;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
note_stores (PATTERN (insn), set_nonzero_bits_and_sign_copies,
NULL);
if (GET_CODE (insn) == CODE_LABEL)
label_tick++;
- else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ else if (INSN_P (insn))
{
/* See if we know about function return values before this
insn based upon SUBREG flags. */
return 0;
for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
- && p != succ && volatile_refs_p (PATTERN (p)))
+ if (INSN_P (p) && p != succ && volatile_refs_p (PATTERN (p)))
return 0;
}
they might affect machine state. */
for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
- && p != succ && volatile_insn_p (PATTERN (p)))
+ if (INSN_P (p) && p != succ && volatile_insn_p (PATTERN (p)))
return 0;
/* If INSN or I2 contains an autoincrement or autodecrement,
REG_LIBCALL note since we don't want to disrupt the contiguity of a
libcall. */
- if (GET_RTX_CLASS (GET_CODE (i3)) != 'i'
- || GET_RTX_CLASS (GET_CODE (i2)) != 'i'
- || (i1 && GET_RTX_CLASS (GET_CODE (i1)) != 'i')
+ if (! INSN_P (i3) || ! INSN_P (i2) || (i1 && ! INSN_P (i1))
#if 0
/* ??? This gives worse code, and appears to be unnecessary, since no
pass after flow uses REG_LIBCALL/REG_RETVAL notes. */
|| insn != BLOCK_HEAD (this_basic_block + 1));
insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_referenced_p (ni2dest, PATTERN (insn)))
+ if (INSN_P (insn) && reg_referenced_p (ni2dest, PATTERN (insn)))
{
for (link = LOG_LINKS (insn); link;
link = XEXP (link, 1))
temp && (this_basic_block == n_basic_blocks - 1
|| BLOCK_HEAD (this_basic_block) != temp);
temp = NEXT_INSN (temp))
- if (temp != i3 && GET_RTX_CLASS (GET_CODE (temp)) == 'i')
+ if (temp != i3 && INSN_P (temp))
for (link = LOG_LINKS (temp); link; link = XEXP (link, 1))
if (XEXP (link, 0) == i2)
XEXP (link, 0) = i3;
for (tem = PREV_INSN (i3); place == 0; tem = PREV_INSN (tem))
{
- if (GET_RTX_CLASS (GET_CODE (tem)) != 'i')
+ if (! INSN_P (tem))
{
if (tem == bb->head)
break;
(insn && (this_basic_block == n_basic_blocks - 1
|| BLOCK_HEAD (this_basic_block + 1) != insn));
insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_overlap_mentioned_p (reg, PATTERN (insn)))
+ if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
{
if (reg_referenced_p (reg, PATTERN (insn)))
place = insn;
pop_topmost_sequence ();
for (; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ if (INSN_P (insn)
&& GET_CODE (PATTERN (insn)) != USE
&& GET_CODE (PATTERN (insn)) != CLOBBER)
{
len = in_use = 0;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i'
+ if (! INSN_P (insn)
|| GET_CODE (PATTERN (insn)) == CLOBBER
|| GET_CODE (PATTERN (insn)) == USE)
goto next_and_done;
next:
insn = next_nonnote_insn (insn);
- if (!insn || GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (!insn || ! INSN_P (insn))
goto done;
/* Let Haifa tell us where it thinks insn group boundaries are. */
len = in_use = 0;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i'
+ if (! INSN_P (insn)
|| GET_CODE (PATTERN (insn)) == CLOBBER
|| GET_CODE (PATTERN (insn)) == USE)
goto next_and_done;
next:
insn = next_nonnote_insn (insn);
- if (!insn || GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (!insn || ! INSN_P (insn))
goto done;
/* Let Haifa tell us where it thinks insn group boundaries are. */
for (insn = first; insn; insn = NEXT_INSN (insn))
{
/* Look for insn. */
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
int insn_code_number;
rtx old;
insn = next_nonnote_insn (insn);
/* This should be our first insn in the loop. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
/* Skip any notes. */
insn = next_nonnote_insn (insn);
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
if (recog_memoized (insn) != CODE_FOR_rptb_end)
{
rtx set;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
set = PATTERN (insn);
if (next == NULL_RTX)
break;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
- if (GET_RTX_CLASS (GET_CODE (next)) != 'i')
+ if (! INSN_P (next))
continue;
set1 = PATTERN (insn);
{
rtx set;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
set = PATTERN (insn);
rtx insn;
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx pat = PATTERN (insn);
int i;
operationss. */
#if 0
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return priority;
if (GET_CODE (PATTERN (insn)) == USE)
while (next && GET_CODE (next) == CODE_LABEL);
if (! next
- || GET_RTX_CLASS (GET_CODE (next)) != 'i'
+ || ! INSN_P (next)
|| GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC
|| recog_memoized (next) == CODE_FOR_consttable_2)
return 0;
dependent REG_NOTE, or some other approach entirely. */
for (insn = first; insn; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx note;
scan && GET_CODE (scan) != CODE_LABEL;
scan = PREV_INSN (scan))
{
- if (GET_RTX_CLASS (GET_CODE (scan)) != 'i')
+ if (! INSN_P (scan))
continue;
if (! reg_mentioned_p (reg, scan))
if (GET_CODE (scan) == CODE_LABEL && ! foundinsn)
break;
- if (GET_RTX_CLASS (GET_CODE (scan)) != 'i')
+ if (! INSN_P (scan))
continue;
/* Don't try to trace forward past a JUMP. To optimize
bzero ((char *) uid_branch, max_uid * sizeof *uid_branch);
for (insn = first; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
else if (INSN_DELETED_P (insn))
{
&& (INTVAL (op) < 0 || INTVAL (op) > max))
return 0;
- if (GET_RTX_CLASS (GET_CODE (next)) == 'i')
+ if (INSN_P (next))
{
next = PATTERN (next);
if (GET_CODE (next) == SET
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END);
insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ if (INSN_P (insn)
&& (GET_CODE (PATTERN (insn)) == SET
|| GET_CODE (PATTERN (insn)) == CLOBBER))
cse_set_around_loop (PATTERN (insn), insn, loop_start);
- else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && GET_CODE (PATTERN (insn)) == PARALLEL)
+ else if (INSN_P (insn) && GET_CODE (PATTERN (insn)) == PARALLEL)
for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET
|| GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == CLOBBER)
for (insn = start; insn && GET_CODE (insn) != CODE_LABEL;
insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
if (GET_CODE (insn) == CALL_INSN)
rtx q;
rtx cse_check_loop_start_value = SET_SRC (x);
for (q = p; q != loop_start; q = NEXT_INSN (q))
- if (GET_RTX_CLASS (GET_CODE (q)) == 'i')
+ if (INSN_P (q))
note_stores (PATTERN (q),
cse_check_loop_start,
&cse_check_loop_start_value);
rtx p = insn, q;
int nsets = 0;
int low_cuid = INSN_CUID (insn), high_cuid = INSN_CUID (insn);
- rtx next =
- GET_RTX_CLASS (GET_CODE (insn)) == 'i' ? insn : next_real_insn (insn);
+ rtx next = INSN_P (insn) ? insn : next_real_insn (insn);
int path_size = data->path_size;
int path_entry = 0;
int i;
/* A PARALLEL can have lots of SETs in it,
especially if it is really an ASM_OPERANDS. */
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
- && GET_CODE (PATTERN (p)) == PARALLEL)
+ if (INSN_P (p) && GET_CODE (PATTERN (p)) == PARALLEL)
nsets += XVECLEN (PATTERN (p), 0);
else if (GET_CODE (p) != NOTE)
nsets += 1;
insn in the function. We must not skip that insn or we may end
up deleting code that is not really dead. */
insn = get_last_insn ();
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
insn = prev_real_insn (insn);
for (; insn; insn = prev)
else if (GET_CODE (SET_DEST (PATTERN (insn))) == CC0
&& ! side_effects_p (SET_SRC (PATTERN (insn)))
&& ((tem = next_nonnote_insn (insn)) == 0
- || GET_RTX_CLASS (GET_CODE (tem)) != 'i'
+ || ! INSN_P (tem)
|| ! reg_referenced_p (cc0_rtx, PATTERN (tem))))
;
#endif
else if (GET_CODE (SET_DEST (elt)) == CC0
&& ! side_effects_p (SET_SRC (elt))
&& ((tem = next_nonnote_insn (insn)) == 0
- || GET_RTX_CLASS (GET_CODE (tem)) != 'i'
+ || ! INSN_P (tem)
|| ! reg_referenced_p (cc0_rtx, PATTERN (tem))))
;
#endif
tree decl;
for (p = insn; p; p = NEXT_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
{
reset_used_flags (PATTERN (p));
reset_used_flags (REG_NOTES (p));
rtx insn;
{
for (; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
insn = XVECEXP (PATTERN (insn), 0, 0);
- if (insn && GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
+ if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
return insn;
return 0;
set LAST and continue from the insn after the one returned.
We can't use next_active_insn here since AFTER may be a note.
Ignore deleted insns, which can be occur if not optimizing. */
- for (tem = NEXT_INSN (before); tem != after;
- tem = NEXT_INSN (tem))
- if (! INSN_DELETED_P (tem)
- && GET_RTX_CLASS (GET_CODE (tem)) == 'i')
+ for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
+ if (! INSN_DELETED_P (tem) && INSN_P (tem))
tem = try_split (PATTERN (tem), tem, 1);
}
/* Avoid infinite loop if the result matches the original pattern. */
#ifdef ENABLE_RTL_CHECKING
if (insn
- && GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ && INSN_P (insn)
&& (returnjump_p (insn)
|| (GET_CODE (insn) == SET
&& SET_DEST (insn) == pc_rtx)))
don't include labels; if the only thing in the block
is a label, then there are still no PC values that
lie within the block. */
- if (GET_RTX_CLASS (GET_CODE (prev)) == 'i')
+ if (INSN_P (prev))
break;
/* We're only interested in NOTEs. */
we must split them before we compute the address/length info. */
for (insn = NEXT_INSN (first); insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx old = insn;
/* Don't split the insn if it has been deleted. */
int log;
INSN_SHUID (insn) = i++;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
/* reorg might make the first insn of a loop being run once only,
and delete the label in front of it. Then we want to apply
{
rtx label;
- for (label = insn; label && GET_RTX_CLASS (GET_CODE (label)) != 'i';
+ for (label = insn; label && ! INSN_P (label);
label = NEXT_INSN (label))
if (GET_CODE (label) == CODE_LABEL)
{
The reg-notes can contain frame pointer refs,
and renumbering them could crash, and should not be needed. */
for (insn = first; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
leaf_renumber_regs_insn (PATTERN (insn));
for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
- if (GET_RTX_CLASS (GET_CODE (XEXP (insn, 0))) == 'i')
+ if (INSN_P (XEXP (insn, 0)))
leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0)));
}
in_rtx->used = 1;
}
- if (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i')
+ if (INSN_P (in_rtx))
{
/* Inside a SEQUENCE, we find insns.
Renumber just the patterns of these insns,
rtx insn;
for (insn = f; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx note;
{
while (1)
{
- if (GET_RTX_CLASS (GET_CODE (head)) == 'i'
+ if (INSN_P (head)
&& for_each_rtx (&PATTERN (head), verify_wide_reg_1, ®no))
return;
if (head == end)
for (insn = f; insn; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
/* Check if insn modifies the stack pointer. */
note_stores (PATTERN (insn), notice_stack_pointer_modification_1,
for (insn = bb->head; ; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx *pprev = ®_NOTES (insn);
rtx link = *pprev;
}
}
- if (GET_RTX_CLASS (GET_CODE (x)) == 'i'
+ if (INSN_P (x)
&& GET_CODE (x) == JUMP_INSN
&& returnjump_p (x) && ! condjump_p (x)
&& ! (NEXT_INSN (x) && GET_CODE (NEXT_INSN (x)) == BARRIER))
int b;
for (i = insns; i; i = NEXT_INSN (i))
- if (GET_RTX_CLASS (GET_CODE (i)) == 'i')
+ if (INSN_P (i))
LOG_LINKS (i) = 0;
for (b = 0; b < n_basic_blocks; b++)
rtx set, prev, prev_set;
rtx note;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
/* Remember the notes in case we delete the insn. */
note = REG_NOTES (insn);
for (ifmwi.pass = 0; ifmwi.pass < 2; ++ifmwi.pass)
for (insn = insns; insn != last_insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
ifmwi.insn = insn;
for_each_rtx (&insn, insns_for_mem_walk, &ifmwi);
bzero ((char *) uid_cuid, n);
for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
uid_cuid[INSN_UID (insn)] = i++;
else
uid_cuid[INSN_UID (insn)] = i;
cuid_insn = (rtx *) gmalloc (n);
bzero ((char *) cuid_insn, n);
for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
CUID_INSN (i++) = insn;
/* Allocate vars to track sets of regs. */
rtx insn;
for (insn = f; insn != 0; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
note_stores (PATTERN (insn), record_set_info, insn);
}
\f
}
#endif
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
if (GET_CODE (insn) == CALL_INSN)
for (insn = BLOCK_HEAD (bb), in_libcall_block = 0;
insn && insn != NEXT_INSN (BLOCK_END (bb));
insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
if (find_reg_note (insn, REG_LIBCALL, NULL_RTX))
in_libcall_block = 1;
/* Keep track of everything modified by this insn. */
/* ??? Need to be careful w.r.t. mods done to INSN. */
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
mark_oprs_set (insn);
}
}
insn != NULL && insn != NEXT_INSN (BLOCK_END (bb));
insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
changed |= cprop_insn (insn, alter_jumps);
{
rtx maybe_cc0_setter = prev_nonnote_insn (insn);
if (maybe_cc0_setter
- && GET_RTX_CLASS (GET_CODE (maybe_cc0_setter)) == 'i'
+ && INSN_P (maybe_cc0_setter)
&& sets_cc0_p (PATTERN (maybe_cc0_setter)))
insn = maybe_cc0_setter;
}
rtx insn = XVECEXP (pat, 0, i);
set_block_num (insn, bb);
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
add_label_notes (PATTERN (insn), new_insn);
note_stores (PATTERN (insn), record_set_info, insn);
rtx reg;
/* Ignore anything that is not a normal insn. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
/* Basically ignore anything that is not a simple SET. We do have
where this wins are reg-reg copies. */
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ if (INSN_P (insn)
&& (set = single_set (insn)) != 0
&& GET_CODE (SET_DEST (set)) == REG
&& reg_allocno[REGNO (SET_DEST (set))] >= 0)
c->insn = first;
c->block = b;
- if (GET_RTX_CLASS (GET_CODE (first)) == 'i')
+ if (INSN_P (first))
{
rtx link;
else
COPY_REG_SET (&c->live_throughout, live_relevant_regs);
- if (GET_RTX_CLASS (GET_CODE (first)) == 'i')
+ if (INSN_P (first))
{
rtx link;
if (b == n_basic_blocks)
{
for (first = NEXT_INSN (first) ; first; first = NEXT_INSN (first))
- if (GET_RTX_CLASS (GET_CODE (first)) == 'i'
- && GET_CODE (PATTERN (first)) != USE)
+ if (INSN_P (first) && GET_CODE (PATTERN (first)) != USE)
abort ();
break;
}
name = GET_NOTE_INSN_NAME (NOTE_LINE_NUMBER (tmp_rtx));
fprintf (fp, " %s", name);
}
- else if (GET_RTX_CLASS (GET_CODE (tmp_rtx)) == 'i')
+ else if (INSN_P (tmp_rtx))
print_rtl_single (fp, PATTERN (tmp_rtx));
else
print_rtl_single (fp, tmp_rtx);
int this_priority;
rtx link;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
if ((this_priority = INSN_PRIORITY (insn)) == 0)
get_bb_head_tail (bb, &head, &tail);
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
return;
next_tail = NEXT_INSN (tail);
rtx next_tail;
rtx insn;
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
return;
next_tail = NEXT_INSN (tail);
rtx x;
/* Handle register life information. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
/* Increment weight for each register born here. */
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
unit = insn_unit (insn);
FIXME: Probably the same thing should be done with REG_SAVE_NOTEs
referencing NOTE_INSN_SETJMP at the end of the block. */
- if (GET_RTX_CLASS (GET_CODE (head)) == 'i')
+ if (INSN_P (head))
{
rtx note;
/* If the only insn left is a NOTE or a CODE_LABEL, then there is no need
to schedule this block. */
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
return (sched_n_insns);
/* Debug info. */
{
rtx next;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
next = NEXT_INSN (insn);
if (INSN_DEP_COUNT (insn) == 0
- && (SCHED_GROUP_P (next) == 0 || GET_RTX_CLASS (GET_CODE (next)) != 'i'))
+ && (SCHED_GROUP_P (next) == 0 || ! INSN_P (next)))
ready[n_ready++] = insn;
if (!(SCHED_GROUP_P (insn)))
target_n_insns++;
src_next_tail = NEXT_INSN (tail);
src_head = head;
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
continue;
for (insn = src_head; insn != src_next_tail; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
if (!CANT_MOVE (insn)
if (INSN_DEP_COUNT (insn) == 0
&& (! next
|| SCHED_GROUP_P (next) == 0
- || GET_RTX_CLASS (GET_CODE (next)) != 'i'))
+ || ! INSN_P (next)))
ready[n_ready++] = insn;
}
}
next_tail = NEXT_INSN (tail);
for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
insn = group_leader (insn);
rtx link;
int unit, range;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
{
int n;
fprintf (dump, ";; %6d ", INSN_UID (insn));
get_bb_head_tail (bb, &head, &tail);
prev_head = PREV_INSN (head);
- if (head == tail
- && (GET_RTX_CLASS (GET_CODE (head)) != 'i'))
+ if (head == tail && (! INSN_P (head)))
return 0;
n_insn = 0;
for (ninsns = 0, insn = get_first_nonparm_insn ();
insn && ninsns < max_insns;
insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
ninsns++;
if (ninsns >= max_insns)
if (insn == first_nonparm_insn)
in_nonparm_insns = 1;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
/* Record what interesting things happen to our parameters. */
note_stores (PATTERN (insn), note_modified_parmregs, NULL);
are valid across the entire function. */
map->const_age++;
for (insn = insns; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ if (INSN_P (insn)
&& map->insn_map[INSN_UID (insn)]
&& REG_NOTES (insn))
{
rtx insn;
for (insn = f; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
if (GET_CODE (insn) == CALL_INSN
&& GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
two_avoided_lines |= (NOTE_LINE_NUMBER (a_line_note)
!= NOTE_LINE_NUMBER (insn));
}
- else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ else if (INSN_P (insn))
contains_insn = 1;
}
if (two_avoided_lines && contains_insn)
insn != NULL && insn != NEXT_INSN (BLOCK_END (bb));
insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
int mode = MODE_NEEDED (e, insn);
rtx link;
for (insn = start; insn && ! equiv_mem_modified; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
if (find_reg_note (insn, REG_DEAD, reg))
for (insn = NEXT_INSN (start); insn != NEXT_INSN (end);
insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && memref_referenced_p (memref, PATTERN (insn)))
+ if (INSN_P (insn) && memref_referenced_p (memref, PATTERN (insn)))
return 1;
return 0;
loop_depth--;
}
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
&& BLOCK_HEAD (block + 1) == insn)
++block;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
{
if (GET_CODE (insn) == NOTE)
{
if (GET_CODE (insn) != NOTE)
insn_number++;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
register rtx link, set;
register int win = 0;
last = XEXP (note, 0);
for (p = NEXT_INSN (insn); p && p != last; p = NEXT_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
{
if (find_reg_note (p, REG_DEAD, r1))
ok = 1;
for (p = NEXT_INSN (loop_start);
p != loop_end
- && GET_CODE (p) != CODE_LABEL && GET_RTX_CLASS (GET_CODE (p)) != 'i'
+ && GET_CODE (p) != CODE_LABEL && ! INSN_P (p)
&& (GET_CODE (p) != NOTE
|| (NOTE_LINE_NUMBER (p) != NOTE_INSN_LOOP_BEG
&& NOTE_LINE_NUMBER (p) != NOTE_INSN_LOOP_END));
p != NULL_RTX;
p = next_insn_in_loop (loop, p))
{
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
- && find_reg_note (p, REG_LIBCALL, NULL_RTX))
+ if (INSN_P (p) && find_reg_note (p, REG_LIBCALL, NULL_RTX))
in_libcall = 1;
- else if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
- && find_reg_note (p, REG_RETVAL, NULL_RTX))
+ else if (INSN_P (p) && find_reg_note (p, REG_RETVAL, NULL_RTX))
in_libcall = 0;
if (GET_CODE (p) == INSN
possible second cse pass. */
for (insn = f; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
struct loop *this_loop = uid_loop[INSN_UID (insn)];
for (insn = from; insn != to; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
++count;
are done. Otherwise, if we hit LOOP->END, wrap around to LOOP->START. */
for (p = loop->scan_start; p != insn; p = NEXT_INSN (p))
{
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
- && reg_overlap_mentioned_p (reg, PATTERN (p)))
+ if (INSN_P (p) && reg_overlap_mentioned_p (reg, PATTERN (p)))
return 1;
if (p == loop->end)
&& insn_dependent_p (giv_insn, next)))
break;
#ifdef HAVE_cc0
- if (! INSN_P (next)
- || ! sets_cc0_p (PATTERN (next)))
+ if (! INSN_P (next) || ! sets_cc0_p (PATTERN (next)))
#endif
dominator = next;
}
{
rtx note;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
if (reg_mentioned_p (old_reg, PATTERN (p)))
{
if ((auto_inc_opt == 1 && sets_cc0_p (PATTERN (v->insn)))
|| (auto_inc_opt == -1
&& (prev = prev_nonnote_insn (v->insn)) != 0
- && GET_RTX_CLASS (GET_CODE (prev)) == 'i'
+ && INSN_P (prev)
&& sets_cc0_p (PATTERN (prev))))
auto_inc_opt = 0;
}
if (p == loop->start)
p = loop->end;
p = PREV_INSN (p);
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
ends_need_computing -= find_life_end (PATTERN (p), stats, p, biv);
}
see if perhaps there are no uses except to count. */
no_use_except_counting = 1;
for (p = loop_start; p != loop_end; p = NEXT_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
{
rtx set = single_set (p);
else if (num_mem_sets <= 1)
{
for (p = loop_start; p != loop_end; p = NEXT_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
num_nonfixed_reads += count_nonfixed_reads (loop, PATTERN (p));
/* If the loop has a single store, and the destination address is
remove all REG_EQUAL notes based on the reversed biv
here. */
for (p = loop_start; p != loop_end; p = NEXT_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
{
rtx *pnote;
rtx set = single_set (p);
rtx_and_int ri;
rtx set;
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
{
/* See if this copies the mem into a register that isn't
modified afterwards. We'll try to do copy propagation
if (GET_CODE (insn) == CODE_LABEL && init_insn)
break;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
/* Is this the initializing insn? */
return;
}
- is_insn = (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i');
+ is_insn = (INSN_P (in_rtx));
/* When printing in VCG format we write INSNs, NOTE, LABEL, and BARRIER
in separate nodes and therefore have to handle them special here. */
for (next = next_nonnote_insn (insn);
next != 0 && GET_CODE (next) != CODE_LABEL;
next = next_nonnote_insn (next))
- if (GET_RTX_CLASS (GET_CODE (next)) == 'i' && dead_or_set_p (next, dest))
+ if (INSN_P (next) && dead_or_set_p (next, dest))
{
for (link = LOG_LINKS (next); link; link = XEXP (link, 1))
if (XEXP (link, 0) == insn)
unsigned int uid, max;
int test;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
uid = INSN_UID (insn);
if (!insn)
return NULL_RTX;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_mentioned_p (ix86_flags_rtx, PATTERN (insn)))
+ if (INSN_P (insn) && reg_mentioned_p (ix86_flags_rtx, PATTERN (insn)))
return insn;
if (GET_CODE (insn) == JUMP_INSN
insn = NEXT_INSN (insn);
if (insn == NULL_RTX)
return 0;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_mentioned_p (dest, insn))
+ if (INSN_P (insn) && reg_mentioned_p (dest, insn))
break;
if (GET_CODE (insn) == JUMP_INSN)
return 0;
alive, death, birth. This lets more important info
overwrite the mode of lesser info. */
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
#ifdef HAVE_cc0
/* In the cc0 case, death is not marked in reg notes,
if (flag_exceptions && GET_CODE (p) == CALL_INSN)
break;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
if (reg_set_p (src, p) || reg_set_p (dest, p)
if (flag_exceptions && GET_CODE (p) == CALL_INSN)
break;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
set = single_set (p);
/* Set to stop at next insn. */
for (q = insn; q != NEXT_INSN (p); q = NEXT_INSN (q))
- if (GET_RTX_CLASS (GET_CODE (q)) == 'i')
+ if (INSN_P (q))
{
if (reg_mentioned_p (dest, PATTERN (q)))
PATTERN (q) = replace_rtx (PATTERN (q), dest, src);
if (flag_exceptions && GET_CODE (p) == CALL_INSN)
return;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
}
if (! p)
subreg = gen_rtx_SUBREG (old_mode, src_reg, 0);
while (p = NEXT_INSN (p), p != insn)
{
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
/* Make a tenative change. */
{
rtx s;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
s = single_set (p);
if (s != 0
if (flag_exceptions && GET_CODE (p) == CALL_INSN)
break;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
if (find_regno_note (p, REG_DEAD, REGNO (dst)))
if (GET_CODE (p) == CODE_LABEL
|| GET_CODE (p) == JUMP_INSN)
break;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
if (reg_overlap_mentioned_p (dst, PATTERN (p)))
{
if (GET_CODE (p) == CODE_LABEL
|| GET_CODE (p) == JUMP_INSN)
break;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
if (reg_overlap_mentioned_p (dst, PATTERN (p)))
{
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
int op_no, match_no;
int success = 0;
if (flag_exceptions && GET_CODE (p) == CALL_INSN)
break;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
length++;
if (flag_exceptions && GET_CODE (p) == CALL_INSN)
break;
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i')
+ if (! INSN_P (p))
continue;
length++;
break;
}
- if (GET_RTX_CLASS (GET_CODE (q)) != 'i')
+ if (! INSN_P (q))
continue;
if (reg_overlap_mentioned_p (src, PATTERN (q))
|| reg_set_p (src, q))
/* emit_insn_after_with_line_notes has no
return value, so search for the new insn. */
insn = p;
- while (GET_RTX_CLASS (GET_CODE (insn)) != 'i'
- || PATTERN (insn) != pat)
+ while (! INSN_P (insn) || PATTERN (insn) != pat)
insn = PREV_INSN (insn);
REG_NOTES (insn) = notes;
break;
}
- if (GET_RTX_CLASS (GET_CODE (q)) != 'i')
+ if (! INSN_P (q))
continue;
s_length2++;
if (reg_set_p (src, q))
if (flag_exceptions && GET_CODE (q) == CALL_INSN)
break;
- if (GET_RTX_CLASS (GET_CODE (q)) != 'i')
+ if (! INSN_P (q))
continue;
if (src != inc_dest && (reg_overlap_mentioned_p (src, PATTERN (q))
|| reg_set_p (src, q)))
struct resources insn_res;
struct resources insn_sets;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
CLEAR_RESOURCE (&insn_sets);
/* Now replace in the uses. */
for (du_idx = def + 1; du_idx < du->high_bound; du_idx++)
{
- if (GET_RTX_CLASS (GET_CODE (VARRAY_RTX (*uid_ruid, du_idx))) != 'i')
+ if (! INSN_P (VARRAY_RTX (*uid_ruid, du_idx)))
continue;
reg_use = regno_use_in (r, PATTERN (VARRAY_RTX (*uid_ruid, du_idx)));
edge e;
basic_block ub = BASIC_BLOCK (use_block);
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
/* If a use's basic block is different than the def's basic block,
return 0;
#endif
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
{
pat = PATTERN (p);
= gen_rtx_INSN_LIST (VOIDmode, insn,
reg_equiv_init[REGNO (SET_SRC (set))]);
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
scan_paradoxical_subregs (PATTERN (insn));
}
and regenerate REG_INC notes that may have been moved around. */
for (insn = first; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx *pnote;
HARD_REG_SET clobbered, allowed;
rtx pat;
- if (GET_RTX_CLASS (GET_CODE (chain->insn)) != 'i'
+ if (! INSN_P (chain->insn)
|| (noperands = asm_noperands (PATTERN (chain->insn))) < 0)
continue;
pat = PATTERN (chain->insn);
known offsets at labels. */
if (GET_CODE (insn) == CODE_LABEL || GET_CODE (insn) == JUMP_INSN
- || (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && REG_NOTES (insn) != 0))
+ || (INSN_P (insn) && REG_NOTES (insn) != 0))
set_label_offsets (insn, insn, 0);
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
rtx old_body = PATTERN (insn);
int old_code = INSN_CODE (insn);
if (GET_CODE (insn) == CODE_LABEL)
set_offsets_for_label (insn);
- else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ else if (INSN_P (insn))
{
rtx oldpat = PATTERN (insn);
if (asm_noperands (PATTERN (insn)) >= 0)
for (p = NEXT_INSN (prev); p != next; p = NEXT_INSN (p))
- if (p != insn && GET_RTX_CLASS (GET_CODE (p)) == 'i'
+ if (p != insn && INSN_P (p)
&& (recog_memoized (p) < 0
|| (extract_insn (p), ! constrain_operands (1))))
{
/* Look at all insns we emitted, just to be safe. */
for (p = get_insns (); p; p = NEXT_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
{
rtx pat = PATTERN (p);
{
if (GET_CODE (i2) == CODE_LABEL)
break;
- if (GET_RTX_CLASS (GET_CODE (i2)) != 'i')
+ if (! INSN_P (i2))
continue;
if (reg_referenced_p (dst, PATTERN (i2)))
{
for (insn = first; insn; insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
reload_cse_simplify (insn);
cselib_process_insn (insn);
if (! fixed_regs[r])
reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
reload_combine_ruid++;
if (GET_CODE (insn) == CODE_LABEL)
last_label_luid = move2add_luid;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
continue;
pat = PATTERN (insn);
/* For simplicity, we only perform this optimization on
if (GET_CODE (trial) == CODE_LABEL)
return 0;
- if (GET_RTX_CLASS (GET_CODE (trial)) != 'i')
+ if (! INSN_P (trial))
continue;
pat = PATTERN (trial);
next = NEXT_INSN (insn);
if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE
- && GET_RTX_CLASS (GET_CODE (XEXP (PATTERN (insn), 0))) == 'i')
+ && INSN_P (XEXP (PATTERN (insn), 0)))
next = delete_insn (insn);
}
/* If INSN is a USE made by update_block, we care about the
underlying insn. Any registers set by the underlying insn
are live since the insn is being done somewhere else. */
- if (GET_RTX_CLASS (GET_CODE (XEXP (PATTERN (insn), 0))) == 'i')
+ if (INSN_P (XEXP (PATTERN (insn), 0)))
mark_set_resources (XEXP (PATTERN (insn), 0), res, 0,
MARK_SRC_DEST_CALL);
/* If this insn is a USE made by update_block, we care about the
underlying insn. */
if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE
- && GET_RTX_CLASS (GET_CODE (XEXP (PATTERN (insn), 0))) == 'i')
+ && INSN_P (XEXP (PATTERN (insn), 0)))
real_insn = XEXP (PATTERN (insn), 0);
if (GET_CODE (real_insn) == CALL_INSN)
return 0;
for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ if (INSN_P (insn)
&& (reg_overlap_mentioned_p (reg, PATTERN (insn))
|| (GET_CODE (insn) == CALL_INSN
&& (find_reg_fusage (insn, USE, reg)
return 0;
for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
+ if (INSN_P (insn)
&& (reg_referenced_p (reg, PATTERN (insn))
|| (GET_CODE (insn) == CALL_INSN
&& find_reg_fusage (insn, USE, reg))))
return 0;
for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_set_p (reg, insn))
+ if (INSN_P (insn) && reg_set_p (reg, insn))
return 1;
return 0;
}
/* We can be passed an insn or part of one. If we are passed an insn,
check if a side-effect of the insn clobbers REG. */
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
if (FIND_REG_INC_NOTE (insn, reg)
|| (GET_CODE (insn) == CALL_INSN
rtx set;
int i;
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
if (GET_CODE (PATTERN (insn)) == SET)
int i;
/* INSN must be an insn. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
/* Only a PARALLEL can have multiple SETs. */
for (p = PREV_INSN (*pinsn); p && GET_CODE (p) != CODE_LABEL;
p = PREV_INSN (p))
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
{
rtx set = single_set (p);
rtx note = find_reg_note (p, REG_EQUAL, NULL_RTX);
&& ! (GET_CODE (insn) == CALL_INSN
&& reg_set_last_last_regno <= FIRST_PSEUDO_REGISTER);
insn = PREV_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
note_stores (PATTERN (insn), reg_set_last_1, NULL);
if (reg_set_last_unknown)
register rtx link;
/* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
register rtx link;
/* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN. */
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
return 0;
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
rtx insn;
for (insn = seq; insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
/* If this is a CALL_PLACEHOLDER, then recursively call ourselves
with each nonempty sequence attached to the CALL_PLACEHOLDER. */
return;
}
- if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ if (! INSN_P (insn))
{
cselib_current_insn = 0;
return;
last = BLOCK_END (bb);
while (1)
{
- if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
+ if (INSN_P (p))
note_stores (PATTERN (p), find_evaluations_1, NULL);
if (p == last)
do
{
insn = next;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
struct rename_context context;
context.done_renames = set_data;
do
{
insn = next;
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
for_each_rtx (&PATTERN (insn),
rename_equivalent_regs_in_insn,
if (GET_CODE (insn) == CODE_LABEL)
break;
- else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
- && reg_set_p (reg, insn))
+ else if (INSN_P (insn) && reg_set_p (reg, insn))
{
/* We found the last insn before the loop that sets the register.
If it sets the entire register, and has a REG_EQUAL note,
}
/* Verify that FIRST_UID is an insn that entirely sets REGNO. */
- if (GET_RTX_CLASS (GET_CODE (p)) != 'i'
- || ! dead_or_set_regno_p (p, regno))
+ if (! INSN_P (p) || ! dead_or_set_regno_p (p, regno))
return 0;
/* FIRST_UID is always executed. */
pool->mark = 0;
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
mark_constants (PATTERN (insn));
for (insn = current_function_epilogue_delay_list;
insn;
insn = XEXP (insn, 1))
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
mark_constants (PATTERN (insn));
/* It's possible that the only reference to a symbol is in a symbol
/* Insns may appear inside a SEQUENCE. Only check the patterns of
insns, not any notes that may be attached. We don't want to mark
a constant just because it happens to appear in a REG_EQUIV note. */
- if (GET_RTX_CLASS (GET_CODE (x)) == 'i')
+ if (INSN_P (x))
{
mark_constants (PATTERN (x));
return;
git://gcc.gnu.org / gcc.git / commitdiff