/* Optimize jump instructions, for GNU compiler.
|
/* Optimize jump instructions, for GNU compiler.
|
Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
|
Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
|
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
|
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
/* This is the pathetic reminder of old fame of the jump-optimization pass
|
/* This is the pathetic reminder of old fame of the jump-optimization pass
|
of the compiler. Now it contains basically a set of utility functions to
|
of the compiler. Now it contains basically a set of utility functions to
|
operate with jumps.
|
operate with jumps.
|
|
|
Each CODE_LABEL has a count of the times it is used
|
Each CODE_LABEL has a count of the times it is used
|
stored in the LABEL_NUSES internal field, and each JUMP_INSN
|
stored in the LABEL_NUSES internal field, and each JUMP_INSN
|
has one label that it refers to stored in the
|
has one label that it refers to stored in the
|
JUMP_LABEL internal field. With this we can detect labels that
|
JUMP_LABEL internal field. With this we can detect labels that
|
become unused because of the deletion of all the jumps that
|
become unused because of the deletion of all the jumps that
|
formerly used them. The JUMP_LABEL info is sometimes looked
|
formerly used them. The JUMP_LABEL info is sometimes looked
|
at by later passes.
|
at by later passes.
|
|
|
The subroutines redirect_jump and invert_jump are used
|
The subroutines redirect_jump and invert_jump are used
|
from other passes as well. */
|
from other passes as well. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "insn-attr.h"
|
#include "insn-attr.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "function.h"
|
#include "function.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "real.h"
|
#include "real.h"
|
#include "except.h"
|
#include "except.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "reload.h"
|
#include "reload.h"
|
#include "predict.h"
|
#include "predict.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "target.h"
|
#include "target.h"
|
|
|
/* Optimize jump y; x: ... y: jumpif... x?
|
/* Optimize jump y; x: ... y: jumpif... x?
|
Don't know if it is worth bothering with. */
|
Don't know if it is worth bothering with. */
|
/* Optimize two cases of conditional jump to conditional jump?
|
/* Optimize two cases of conditional jump to conditional jump?
|
This can never delete any instruction or make anything dead,
|
This can never delete any instruction or make anything dead,
|
or even change what is live at any point.
|
or even change what is live at any point.
|
So perhaps let combiner do it. */
|
So perhaps let combiner do it. */
|
|
|
static void init_label_info (rtx);
|
static void init_label_info (rtx);
|
static void mark_all_labels (rtx);
|
static void mark_all_labels (rtx);
|
static void delete_computation (rtx);
|
static void delete_computation (rtx);
|
static void redirect_exp_1 (rtx *, rtx, rtx, rtx);
|
static void redirect_exp_1 (rtx *, rtx, rtx, rtx);
|
static int invert_exp_1 (rtx, rtx);
|
static int invert_exp_1 (rtx, rtx);
|
static int returnjump_p_1 (rtx *, void *);
|
static int returnjump_p_1 (rtx *, void *);
|
static void delete_prior_computation (rtx, rtx);
|
static void delete_prior_computation (rtx, rtx);
|
|
|
/* Alternate entry into the jump optimizer. This entry point only rebuilds
|
/* Alternate entry into the jump optimizer. This entry point only rebuilds
|
the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
|
the JUMP_LABEL field in jumping insns and REG_LABEL notes in non-jumping
|
instructions. */
|
instructions. */
|
void
|
void
|
rebuild_jump_labels (rtx f)
|
rebuild_jump_labels (rtx f)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
timevar_push (TV_REBUILD_JUMP);
|
timevar_push (TV_REBUILD_JUMP);
|
init_label_info (f);
|
init_label_info (f);
|
mark_all_labels (f);
|
mark_all_labels (f);
|
|
|
/* Keep track of labels used from static data; we don't track them
|
/* Keep track of labels used from static data; we don't track them
|
closely enough to delete them here, so make sure their reference
|
closely enough to delete them here, so make sure their reference
|
count doesn't drop to zero. */
|
count doesn't drop to zero. */
|
|
|
for (insn = forced_labels; insn; insn = XEXP (insn, 1))
|
for (insn = forced_labels; insn; insn = XEXP (insn, 1))
|
if (LABEL_P (XEXP (insn, 0)))
|
if (LABEL_P (XEXP (insn, 0)))
|
LABEL_NUSES (XEXP (insn, 0))++;
|
LABEL_NUSES (XEXP (insn, 0))++;
|
timevar_pop (TV_REBUILD_JUMP);
|
timevar_pop (TV_REBUILD_JUMP);
|
}
|
}
|
|
|
/* Some old code expects exactly one BARRIER as the NEXT_INSN of a
|
/* Some old code expects exactly one BARRIER as the NEXT_INSN of a
|
non-fallthru insn. This is not generally true, as multiple barriers
|
non-fallthru insn. This is not generally true, as multiple barriers
|
may have crept in, or the BARRIER may be separated from the last
|
may have crept in, or the BARRIER may be separated from the last
|
real insn by one or more NOTEs.
|
real insn by one or more NOTEs.
|
|
|
This simple pass moves barriers and removes duplicates so that the
|
This simple pass moves barriers and removes duplicates so that the
|
old code is happy.
|
old code is happy.
|
*/
|
*/
|
unsigned int
|
unsigned int
|
cleanup_barriers (void)
|
cleanup_barriers (void)
|
{
|
{
|
rtx insn, next, prev;
|
rtx insn, next, prev;
|
for (insn = get_insns (); insn; insn = next)
|
for (insn = get_insns (); insn; insn = next)
|
{
|
{
|
next = NEXT_INSN (insn);
|
next = NEXT_INSN (insn);
|
if (BARRIER_P (insn))
|
if (BARRIER_P (insn))
|
{
|
{
|
prev = prev_nonnote_insn (insn);
|
prev = prev_nonnote_insn (insn);
|
if (BARRIER_P (prev))
|
if (BARRIER_P (prev))
|
delete_insn (insn);
|
delete_insn (insn);
|
else if (prev != PREV_INSN (insn))
|
else if (prev != PREV_INSN (insn))
|
reorder_insns (insn, insn, prev);
|
reorder_insns (insn, insn, prev);
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_cleanup_barriers =
|
struct tree_opt_pass pass_cleanup_barriers =
|
{
|
{
|
"barriers", /* name */
|
"barriers", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
cleanup_barriers, /* execute */
|
cleanup_barriers, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
0, /* tv_id */
|
0, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
unsigned int
|
unsigned int
|
purge_line_number_notes (void)
|
purge_line_number_notes (void)
|
{
|
{
|
rtx last_note = 0;
|
rtx last_note = 0;
|
rtx insn;
|
rtx insn;
|
/* Delete extraneous line number notes.
|
/* Delete extraneous line number notes.
|
Note that two consecutive notes for different lines are not really
|
Note that two consecutive notes for different lines are not really
|
extraneous. There should be some indication where that line belonged,
|
extraneous. There should be some indication where that line belonged,
|
even if it became empty. */
|
even if it became empty. */
|
|
|
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
|
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
|
if (NOTE_P (insn))
|
if (NOTE_P (insn))
|
{
|
{
|
if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
|
if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
|
/* Any previous line note was for the prologue; gdb wants a new
|
/* Any previous line note was for the prologue; gdb wants a new
|
note after the prologue even if it is for the same line. */
|
note after the prologue even if it is for the same line. */
|
last_note = NULL_RTX;
|
last_note = NULL_RTX;
|
else if (NOTE_LINE_NUMBER (insn) >= 0)
|
else if (NOTE_LINE_NUMBER (insn) >= 0)
|
{
|
{
|
/* Delete this note if it is identical to previous note. */
|
/* Delete this note if it is identical to previous note. */
|
if (last_note
|
if (last_note
|
#ifdef USE_MAPPED_LOCATION
|
#ifdef USE_MAPPED_LOCATION
|
&& NOTE_SOURCE_LOCATION (insn) == NOTE_SOURCE_LOCATION (last_note)
|
&& NOTE_SOURCE_LOCATION (insn) == NOTE_SOURCE_LOCATION (last_note)
|
#else
|
#else
|
&& NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last_note)
|
&& NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last_note)
|
&& NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last_note)
|
&& NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last_note)
|
#endif
|
#endif
|
)
|
)
|
{
|
{
|
delete_related_insns (insn);
|
delete_related_insns (insn);
|
continue;
|
continue;
|
}
|
}
|
|
|
last_note = insn;
|
last_note = insn;
|
}
|
}
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_purge_lineno_notes =
|
struct tree_opt_pass pass_purge_lineno_notes =
|
{
|
{
|
"elnotes", /* name */
|
"elnotes", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
purge_line_number_notes, /* execute */
|
purge_line_number_notes, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
0, /* tv_id */
|
0, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func, /* todo_flags_finish */
|
TODO_dump_func, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
|
|
/* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
|
/* Initialize LABEL_NUSES and JUMP_LABEL fields. Delete any REG_LABEL
|
notes whose labels don't occur in the insn any more. Returns the
|
notes whose labels don't occur in the insn any more. Returns the
|
largest INSN_UID found. */
|
largest INSN_UID found. */
|
static void
|
static void
|
init_label_info (rtx f)
|
init_label_info (rtx f)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
for (insn = f; insn; insn = NEXT_INSN (insn))
|
for (insn = f; insn; insn = NEXT_INSN (insn))
|
if (LABEL_P (insn))
|
if (LABEL_P (insn))
|
LABEL_NUSES (insn) = (LABEL_PRESERVE_P (insn) != 0);
|
LABEL_NUSES (insn) = (LABEL_PRESERVE_P (insn) != 0);
|
else if (JUMP_P (insn))
|
else if (JUMP_P (insn))
|
JUMP_LABEL (insn) = 0;
|
JUMP_LABEL (insn) = 0;
|
else if (NONJUMP_INSN_P (insn) || CALL_P (insn))
|
else if (NONJUMP_INSN_P (insn) || CALL_P (insn))
|
{
|
{
|
rtx note, next;
|
rtx note, next;
|
|
|
for (note = REG_NOTES (insn); note; note = next)
|
for (note = REG_NOTES (insn); note; note = next)
|
{
|
{
|
next = XEXP (note, 1);
|
next = XEXP (note, 1);
|
if (REG_NOTE_KIND (note) == REG_LABEL
|
if (REG_NOTE_KIND (note) == REG_LABEL
|
&& ! reg_mentioned_p (XEXP (note, 0), PATTERN (insn)))
|
&& ! reg_mentioned_p (XEXP (note, 0), PATTERN (insn)))
|
remove_note (insn, note);
|
remove_note (insn, note);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Mark the label each jump jumps to.
|
/* Mark the label each jump jumps to.
|
Combine consecutive labels, and count uses of labels. */
|
Combine consecutive labels, and count uses of labels. */
|
|
|
static void
|
static void
|
mark_all_labels (rtx f)
|
mark_all_labels (rtx f)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
for (insn = f; insn; insn = NEXT_INSN (insn))
|
for (insn = f; insn; insn = NEXT_INSN (insn))
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
mark_jump_label (PATTERN (insn), insn, 0);
|
mark_jump_label (PATTERN (insn), insn, 0);
|
if (! INSN_DELETED_P (insn) && JUMP_P (insn))
|
if (! INSN_DELETED_P (insn) && JUMP_P (insn))
|
{
|
{
|
/* When we know the LABEL_REF contained in a REG used in
|
/* When we know the LABEL_REF contained in a REG used in
|
an indirect jump, we'll have a REG_LABEL note so that
|
an indirect jump, we'll have a REG_LABEL note so that
|
flow can tell where it's going. */
|
flow can tell where it's going. */
|
if (JUMP_LABEL (insn) == 0)
|
if (JUMP_LABEL (insn) == 0)
|
{
|
{
|
rtx label_note = find_reg_note (insn, REG_LABEL, NULL_RTX);
|
rtx label_note = find_reg_note (insn, REG_LABEL, NULL_RTX);
|
if (label_note)
|
if (label_note)
|
{
|
{
|
/* But a LABEL_REF around the REG_LABEL note, so
|
/* But a LABEL_REF around the REG_LABEL note, so
|
that we can canonicalize it. */
|
that we can canonicalize it. */
|
rtx label_ref = gen_rtx_LABEL_REF (Pmode,
|
rtx label_ref = gen_rtx_LABEL_REF (Pmode,
|
XEXP (label_note, 0));
|
XEXP (label_note, 0));
|
|
|
mark_jump_label (label_ref, insn, 0);
|
mark_jump_label (label_ref, insn, 0);
|
XEXP (label_note, 0) = XEXP (label_ref, 0);
|
XEXP (label_note, 0) = XEXP (label_ref, 0);
|
JUMP_LABEL (insn) = XEXP (label_note, 0);
|
JUMP_LABEL (insn) = XEXP (label_note, 0);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Move all block-beg, block-end and loop-beg notes between START and END out
|
/* Move all block-beg, block-end and loop-beg notes between START and END out
|
before START. START and END may be such notes. Returns the values of the
|
before START. START and END may be such notes. Returns the values of the
|
new starting and ending insns, which may be different if the original ones
|
new starting and ending insns, which may be different if the original ones
|
were such notes. Return true if there were only such notes and no real
|
were such notes. Return true if there were only such notes and no real
|
instructions. */
|
instructions. */
|
|
|
bool
|
bool
|
squeeze_notes (rtx* startp, rtx* endp)
|
squeeze_notes (rtx* startp, rtx* endp)
|
{
|
{
|
rtx start = *startp;
|
rtx start = *startp;
|
rtx end = *endp;
|
rtx end = *endp;
|
|
|
rtx insn;
|
rtx insn;
|
rtx next;
|
rtx next;
|
rtx last = NULL;
|
rtx last = NULL;
|
rtx past_end = NEXT_INSN (end);
|
rtx past_end = NEXT_INSN (end);
|
|
|
for (insn = start; insn != past_end; insn = next)
|
for (insn = start; insn != past_end; insn = next)
|
{
|
{
|
next = NEXT_INSN (insn);
|
next = NEXT_INSN (insn);
|
if (NOTE_P (insn)
|
if (NOTE_P (insn)
|
&& (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
|
&& (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
|
|| NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG))
|
|| NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG))
|
{
|
{
|
/* BLOCK_BEG or BLOCK_END notes only exist in the `final' pass. */
|
/* BLOCK_BEG or BLOCK_END notes only exist in the `final' pass. */
|
gcc_assert (NOTE_LINE_NUMBER (insn) != NOTE_INSN_BLOCK_BEG
|
gcc_assert (NOTE_LINE_NUMBER (insn) != NOTE_INSN_BLOCK_BEG
|
&& NOTE_LINE_NUMBER (insn) != NOTE_INSN_BLOCK_END);
|
&& NOTE_LINE_NUMBER (insn) != NOTE_INSN_BLOCK_END);
|
|
|
if (insn == start)
|
if (insn == start)
|
start = next;
|
start = next;
|
else
|
else
|
{
|
{
|
rtx prev = PREV_INSN (insn);
|
rtx prev = PREV_INSN (insn);
|
PREV_INSN (insn) = PREV_INSN (start);
|
PREV_INSN (insn) = PREV_INSN (start);
|
NEXT_INSN (insn) = start;
|
NEXT_INSN (insn) = start;
|
NEXT_INSN (PREV_INSN (insn)) = insn;
|
NEXT_INSN (PREV_INSN (insn)) = insn;
|
PREV_INSN (NEXT_INSN (insn)) = insn;
|
PREV_INSN (NEXT_INSN (insn)) = insn;
|
NEXT_INSN (prev) = next;
|
NEXT_INSN (prev) = next;
|
PREV_INSN (next) = prev;
|
PREV_INSN (next) = prev;
|
}
|
}
|
}
|
}
|
else
|
else
|
last = insn;
|
last = insn;
|
}
|
}
|
|
|
/* There were no real instructions. */
|
/* There were no real instructions. */
|
if (start == past_end)
|
if (start == past_end)
|
return true;
|
return true;
|
|
|
end = last;
|
end = last;
|
|
|
*startp = start;
|
*startp = start;
|
*endp = end;
|
*endp = end;
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return the label before INSN, or put a new label there. */
|
/* Return the label before INSN, or put a new label there. */
|
|
|
rtx
|
rtx
|
get_label_before (rtx insn)
|
get_label_before (rtx insn)
|
{
|
{
|
rtx label;
|
rtx label;
|
|
|
/* Find an existing label at this point
|
/* Find an existing label at this point
|
or make a new one if there is none. */
|
or make a new one if there is none. */
|
label = prev_nonnote_insn (insn);
|
label = prev_nonnote_insn (insn);
|
|
|
if (label == 0 || !LABEL_P (label))
|
if (label == 0 || !LABEL_P (label))
|
{
|
{
|
rtx prev = PREV_INSN (insn);
|
rtx prev = PREV_INSN (insn);
|
|
|
label = gen_label_rtx ();
|
label = gen_label_rtx ();
|
emit_label_after (label, prev);
|
emit_label_after (label, prev);
|
LABEL_NUSES (label) = 0;
|
LABEL_NUSES (label) = 0;
|
}
|
}
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Return the label after INSN, or put a new label there. */
|
/* Return the label after INSN, or put a new label there. */
|
|
|
rtx
|
rtx
|
get_label_after (rtx insn)
|
get_label_after (rtx insn)
|
{
|
{
|
rtx label;
|
rtx label;
|
|
|
/* Find an existing label at this point
|
/* Find an existing label at this point
|
or make a new one if there is none. */
|
or make a new one if there is none. */
|
label = next_nonnote_insn (insn);
|
label = next_nonnote_insn (insn);
|
|
|
if (label == 0 || !LABEL_P (label))
|
if (label == 0 || !LABEL_P (label))
|
{
|
{
|
label = gen_label_rtx ();
|
label = gen_label_rtx ();
|
emit_label_after (label, insn);
|
emit_label_after (label, insn);
|
LABEL_NUSES (label) = 0;
|
LABEL_NUSES (label) = 0;
|
}
|
}
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
|
/* Given a comparison (CODE ARG0 ARG1), inside an insn, INSN, return a code
|
of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
|
of reversed comparison if it is possible to do so. Otherwise return UNKNOWN.
|
UNKNOWN may be returned in case we are having CC_MODE compare and we don't
|
UNKNOWN may be returned in case we are having CC_MODE compare and we don't
|
know whether it's source is floating point or integer comparison. Machine
|
know whether it's source is floating point or integer comparison. Machine
|
description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
|
description should define REVERSIBLE_CC_MODE and REVERSE_CONDITION macros
|
to help this function avoid overhead in these cases. */
|
to help this function avoid overhead in these cases. */
|
enum rtx_code
|
enum rtx_code
|
reversed_comparison_code_parts (enum rtx_code code, rtx arg0, rtx arg1, rtx insn)
|
reversed_comparison_code_parts (enum rtx_code code, rtx arg0, rtx arg1, rtx insn)
|
{
|
{
|
enum machine_mode mode;
|
enum machine_mode mode;
|
|
|
/* If this is not actually a comparison, we can't reverse it. */
|
/* If this is not actually a comparison, we can't reverse it. */
|
if (GET_RTX_CLASS (code) != RTX_COMPARE
|
if (GET_RTX_CLASS (code) != RTX_COMPARE
|
&& GET_RTX_CLASS (code) != RTX_COMM_COMPARE)
|
&& GET_RTX_CLASS (code) != RTX_COMM_COMPARE)
|
return UNKNOWN;
|
return UNKNOWN;
|
|
|
mode = GET_MODE (arg0);
|
mode = GET_MODE (arg0);
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
mode = GET_MODE (arg1);
|
mode = GET_MODE (arg1);
|
|
|
/* First see if machine description supplies us way to reverse the
|
/* First see if machine description supplies us way to reverse the
|
comparison. Give it priority over everything else to allow
|
comparison. Give it priority over everything else to allow
|
machine description to do tricks. */
|
machine description to do tricks. */
|
if (GET_MODE_CLASS (mode) == MODE_CC
|
if (GET_MODE_CLASS (mode) == MODE_CC
|
&& REVERSIBLE_CC_MODE (mode))
|
&& REVERSIBLE_CC_MODE (mode))
|
{
|
{
|
#ifdef REVERSE_CONDITION
|
#ifdef REVERSE_CONDITION
|
return REVERSE_CONDITION (code, mode);
|
return REVERSE_CONDITION (code, mode);
|
#endif
|
#endif
|
return reverse_condition (code);
|
return reverse_condition (code);
|
}
|
}
|
|
|
/* Try a few special cases based on the comparison code. */
|
/* Try a few special cases based on the comparison code. */
|
switch (code)
|
switch (code)
|
{
|
{
|
case GEU:
|
case GEU:
|
case GTU:
|
case GTU:
|
case LEU:
|
case LEU:
|
case LTU:
|
case LTU:
|
case NE:
|
case NE:
|
case EQ:
|
case EQ:
|
/* It is always safe to reverse EQ and NE, even for the floating
|
/* It is always safe to reverse EQ and NE, even for the floating
|
point. Similarly the unsigned comparisons are never used for
|
point. Similarly the unsigned comparisons are never used for
|
floating point so we can reverse them in the default way. */
|
floating point so we can reverse them in the default way. */
|
return reverse_condition (code);
|
return reverse_condition (code);
|
case ORDERED:
|
case ORDERED:
|
case UNORDERED:
|
case UNORDERED:
|
case LTGT:
|
case LTGT:
|
case UNEQ:
|
case UNEQ:
|
/* In case we already see unordered comparison, we can be sure to
|
/* In case we already see unordered comparison, we can be sure to
|
be dealing with floating point so we don't need any more tests. */
|
be dealing with floating point so we don't need any more tests. */
|
return reverse_condition_maybe_unordered (code);
|
return reverse_condition_maybe_unordered (code);
|
case UNLT:
|
case UNLT:
|
case UNLE:
|
case UNLE:
|
case UNGT:
|
case UNGT:
|
case UNGE:
|
case UNGE:
|
/* We don't have safe way to reverse these yet. */
|
/* We don't have safe way to reverse these yet. */
|
return UNKNOWN;
|
return UNKNOWN;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
if (GET_MODE_CLASS (mode) == MODE_CC || CC0_P (arg0))
|
if (GET_MODE_CLASS (mode) == MODE_CC || CC0_P (arg0))
|
{
|
{
|
rtx prev;
|
rtx prev;
|
/* Try to search for the comparison to determine the real mode.
|
/* Try to search for the comparison to determine the real mode.
|
This code is expensive, but with sane machine description it
|
This code is expensive, but with sane machine description it
|
will be never used, since REVERSIBLE_CC_MODE will return true
|
will be never used, since REVERSIBLE_CC_MODE will return true
|
in all cases. */
|
in all cases. */
|
if (! insn)
|
if (! insn)
|
return UNKNOWN;
|
return UNKNOWN;
|
|
|
for (prev = prev_nonnote_insn (insn);
|
for (prev = prev_nonnote_insn (insn);
|
prev != 0 && !LABEL_P (prev);
|
prev != 0 && !LABEL_P (prev);
|
prev = prev_nonnote_insn (prev))
|
prev = prev_nonnote_insn (prev))
|
{
|
{
|
rtx set = set_of (arg0, prev);
|
rtx set = set_of (arg0, prev);
|
if (set && GET_CODE (set) == SET
|
if (set && GET_CODE (set) == SET
|
&& rtx_equal_p (SET_DEST (set), arg0))
|
&& rtx_equal_p (SET_DEST (set), arg0))
|
{
|
{
|
rtx src = SET_SRC (set);
|
rtx src = SET_SRC (set);
|
|
|
if (GET_CODE (src) == COMPARE)
|
if (GET_CODE (src) == COMPARE)
|
{
|
{
|
rtx comparison = src;
|
rtx comparison = src;
|
arg0 = XEXP (src, 0);
|
arg0 = XEXP (src, 0);
|
mode = GET_MODE (arg0);
|
mode = GET_MODE (arg0);
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
mode = GET_MODE (XEXP (comparison, 1));
|
mode = GET_MODE (XEXP (comparison, 1));
|
break;
|
break;
|
}
|
}
|
/* We can get past reg-reg moves. This may be useful for model
|
/* We can get past reg-reg moves. This may be useful for model
|
of i387 comparisons that first move flag registers around. */
|
of i387 comparisons that first move flag registers around. */
|
if (REG_P (src))
|
if (REG_P (src))
|
{
|
{
|
arg0 = src;
|
arg0 = src;
|
continue;
|
continue;
|
}
|
}
|
}
|
}
|
/* If register is clobbered in some ununderstandable way,
|
/* If register is clobbered in some ununderstandable way,
|
give up. */
|
give up. */
|
if (set)
|
if (set)
|
return UNKNOWN;
|
return UNKNOWN;
|
}
|
}
|
}
|
}
|
|
|
/* Test for an integer condition, or a floating-point comparison
|
/* Test for an integer condition, or a floating-point comparison
|
in which NaNs can be ignored. */
|
in which NaNs can be ignored. */
|
if (GET_CODE (arg0) == CONST_INT
|
if (GET_CODE (arg0) == CONST_INT
|
|| (GET_MODE (arg0) != VOIDmode
|
|| (GET_MODE (arg0) != VOIDmode
|
&& GET_MODE_CLASS (mode) != MODE_CC
|
&& GET_MODE_CLASS (mode) != MODE_CC
|
&& !HONOR_NANS (mode)))
|
&& !HONOR_NANS (mode)))
|
return reverse_condition (code);
|
return reverse_condition (code);
|
|
|
return UNKNOWN;
|
return UNKNOWN;
|
}
|
}
|
|
|
/* A wrapper around the previous function to take COMPARISON as rtx
|
/* A wrapper around the previous function to take COMPARISON as rtx
|
expression. This simplifies many callers. */
|
expression. This simplifies many callers. */
|
enum rtx_code
|
enum rtx_code
|
reversed_comparison_code (rtx comparison, rtx insn)
|
reversed_comparison_code (rtx comparison, rtx insn)
|
{
|
{
|
if (!COMPARISON_P (comparison))
|
if (!COMPARISON_P (comparison))
|
return UNKNOWN;
|
return UNKNOWN;
|
return reversed_comparison_code_parts (GET_CODE (comparison),
|
return reversed_comparison_code_parts (GET_CODE (comparison),
|
XEXP (comparison, 0),
|
XEXP (comparison, 0),
|
XEXP (comparison, 1), insn);
|
XEXP (comparison, 1), insn);
|
}
|
}
|
|
|
/* Return comparison with reversed code of EXP.
|
/* Return comparison with reversed code of EXP.
|
Return NULL_RTX in case we fail to do the reversal. */
|
Return NULL_RTX in case we fail to do the reversal. */
|
rtx
|
rtx
|
reversed_comparison (rtx exp, enum machine_mode mode)
|
reversed_comparison (rtx exp, enum machine_mode mode)
|
{
|
{
|
enum rtx_code reversed_code = reversed_comparison_code (exp, NULL_RTX);
|
enum rtx_code reversed_code = reversed_comparison_code (exp, NULL_RTX);
|
if (reversed_code == UNKNOWN)
|
if (reversed_code == UNKNOWN)
|
return NULL_RTX;
|
return NULL_RTX;
|
else
|
else
|
return simplify_gen_relational (reversed_code, mode, VOIDmode,
|
return simplify_gen_relational (reversed_code, mode, VOIDmode,
|
XEXP (exp, 0), XEXP (exp, 1));
|
XEXP (exp, 0), XEXP (exp, 1));
|
}
|
}
|
|
|
|
|
/* Given an rtx-code for a comparison, return the code for the negated
|
/* Given an rtx-code for a comparison, return the code for the negated
|
comparison. If no such code exists, return UNKNOWN.
|
comparison. If no such code exists, return UNKNOWN.
|
|
|
WATCH OUT! reverse_condition is not safe to use on a jump that might
|
WATCH OUT! reverse_condition is not safe to use on a jump that might
|
be acting on the results of an IEEE floating point comparison, because
|
be acting on the results of an IEEE floating point comparison, because
|
of the special treatment of non-signaling nans in comparisons.
|
of the special treatment of non-signaling nans in comparisons.
|
Use reversed_comparison_code instead. */
|
Use reversed_comparison_code instead. */
|
|
|
enum rtx_code
|
enum rtx_code
|
reverse_condition (enum rtx_code code)
|
reverse_condition (enum rtx_code code)
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case EQ:
|
case EQ:
|
return NE;
|
return NE;
|
case NE:
|
case NE:
|
return EQ;
|
return EQ;
|
case GT:
|
case GT:
|
return LE;
|
return LE;
|
case GE:
|
case GE:
|
return LT;
|
return LT;
|
case LT:
|
case LT:
|
return GE;
|
return GE;
|
case LE:
|
case LE:
|
return GT;
|
return GT;
|
case GTU:
|
case GTU:
|
return LEU;
|
return LEU;
|
case GEU:
|
case GEU:
|
return LTU;
|
return LTU;
|
case LTU:
|
case LTU:
|
return GEU;
|
return GEU;
|
case LEU:
|
case LEU:
|
return GTU;
|
return GTU;
|
case UNORDERED:
|
case UNORDERED:
|
return ORDERED;
|
return ORDERED;
|
case ORDERED:
|
case ORDERED:
|
return UNORDERED;
|
return UNORDERED;
|
|
|
case UNLT:
|
case UNLT:
|
case UNLE:
|
case UNLE:
|
case UNGT:
|
case UNGT:
|
case UNGE:
|
case UNGE:
|
case UNEQ:
|
case UNEQ:
|
case LTGT:
|
case LTGT:
|
return UNKNOWN;
|
return UNKNOWN;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Similar, but we're allowed to generate unordered comparisons, which
|
/* Similar, but we're allowed to generate unordered comparisons, which
|
makes it safe for IEEE floating-point. Of course, we have to recognize
|
makes it safe for IEEE floating-point. Of course, we have to recognize
|
that the target will support them too... */
|
that the target will support them too... */
|
|
|
enum rtx_code
|
enum rtx_code
|
reverse_condition_maybe_unordered (enum rtx_code code)
|
reverse_condition_maybe_unordered (enum rtx_code code)
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case EQ:
|
case EQ:
|
return NE;
|
return NE;
|
case NE:
|
case NE:
|
return EQ;
|
return EQ;
|
case GT:
|
case GT:
|
return UNLE;
|
return UNLE;
|
case GE:
|
case GE:
|
return UNLT;
|
return UNLT;
|
case LT:
|
case LT:
|
return UNGE;
|
return UNGE;
|
case LE:
|
case LE:
|
return UNGT;
|
return UNGT;
|
case LTGT:
|
case LTGT:
|
return UNEQ;
|
return UNEQ;
|
case UNORDERED:
|
case UNORDERED:
|
return ORDERED;
|
return ORDERED;
|
case ORDERED:
|
case ORDERED:
|
return UNORDERED;
|
return UNORDERED;
|
case UNLT:
|
case UNLT:
|
return GE;
|
return GE;
|
case UNLE:
|
case UNLE:
|
return GT;
|
return GT;
|
case UNGT:
|
case UNGT:
|
return LE;
|
return LE;
|
case UNGE:
|
case UNGE:
|
return LT;
|
return LT;
|
case UNEQ:
|
case UNEQ:
|
return LTGT;
|
return LTGT;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Similar, but return the code when two operands of a comparison are swapped.
|
/* Similar, but return the code when two operands of a comparison are swapped.
|
This IS safe for IEEE floating-point. */
|
This IS safe for IEEE floating-point. */
|
|
|
enum rtx_code
|
enum rtx_code
|
swap_condition (enum rtx_code code)
|
swap_condition (enum rtx_code code)
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case EQ:
|
case EQ:
|
case NE:
|
case NE:
|
case UNORDERED:
|
case UNORDERED:
|
case ORDERED:
|
case ORDERED:
|
case UNEQ:
|
case UNEQ:
|
case LTGT:
|
case LTGT:
|
return code;
|
return code;
|
|
|
case GT:
|
case GT:
|
return LT;
|
return LT;
|
case GE:
|
case GE:
|
return LE;
|
return LE;
|
case LT:
|
case LT:
|
return GT;
|
return GT;
|
case LE:
|
case LE:
|
return GE;
|
return GE;
|
case GTU:
|
case GTU:
|
return LTU;
|
return LTU;
|
case GEU:
|
case GEU:
|
return LEU;
|
return LEU;
|
case LTU:
|
case LTU:
|
return GTU;
|
return GTU;
|
case LEU:
|
case LEU:
|
return GEU;
|
return GEU;
|
case UNLT:
|
case UNLT:
|
return UNGT;
|
return UNGT;
|
case UNLE:
|
case UNLE:
|
return UNGE;
|
return UNGE;
|
case UNGT:
|
case UNGT:
|
return UNLT;
|
return UNLT;
|
case UNGE:
|
case UNGE:
|
return UNLE;
|
return UNLE;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Given a comparison CODE, return the corresponding unsigned comparison.
|
/* Given a comparison CODE, return the corresponding unsigned comparison.
|
If CODE is an equality comparison or already an unsigned comparison,
|
If CODE is an equality comparison or already an unsigned comparison,
|
CODE is returned. */
|
CODE is returned. */
|
|
|
enum rtx_code
|
enum rtx_code
|
unsigned_condition (enum rtx_code code)
|
unsigned_condition (enum rtx_code code)
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case EQ:
|
case EQ:
|
case NE:
|
case NE:
|
case GTU:
|
case GTU:
|
case GEU:
|
case GEU:
|
case LTU:
|
case LTU:
|
case LEU:
|
case LEU:
|
return code;
|
return code;
|
|
|
case GT:
|
case GT:
|
return GTU;
|
return GTU;
|
case GE:
|
case GE:
|
return GEU;
|
return GEU;
|
case LT:
|
case LT:
|
return LTU;
|
return LTU;
|
case LE:
|
case LE:
|
return LEU;
|
return LEU;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Similarly, return the signed version of a comparison. */
|
/* Similarly, return the signed version of a comparison. */
|
|
|
enum rtx_code
|
enum rtx_code
|
signed_condition (enum rtx_code code)
|
signed_condition (enum rtx_code code)
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case EQ:
|
case EQ:
|
case NE:
|
case NE:
|
case GT:
|
case GT:
|
case GE:
|
case GE:
|
case LT:
|
case LT:
|
case LE:
|
case LE:
|
return code;
|
return code;
|
|
|
case GTU:
|
case GTU:
|
return GT;
|
return GT;
|
case GEU:
|
case GEU:
|
return GE;
|
return GE;
|
case LTU:
|
case LTU:
|
return LT;
|
return LT;
|
case LEU:
|
case LEU:
|
return LE;
|
return LE;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Return nonzero if CODE1 is more strict than CODE2, i.e., if the
|
/* Return nonzero if CODE1 is more strict than CODE2, i.e., if the
|
truth of CODE1 implies the truth of CODE2. */
|
truth of CODE1 implies the truth of CODE2. */
|
|
|
int
|
int
|
comparison_dominates_p (enum rtx_code code1, enum rtx_code code2)
|
comparison_dominates_p (enum rtx_code code1, enum rtx_code code2)
|
{
|
{
|
/* UNKNOWN comparison codes can happen as a result of trying to revert
|
/* UNKNOWN comparison codes can happen as a result of trying to revert
|
comparison codes.
|
comparison codes.
|
They can't match anything, so we have to reject them here. */
|
They can't match anything, so we have to reject them here. */
|
if (code1 == UNKNOWN || code2 == UNKNOWN)
|
if (code1 == UNKNOWN || code2 == UNKNOWN)
|
return 0;
|
return 0;
|
|
|
if (code1 == code2)
|
if (code1 == code2)
|
return 1;
|
return 1;
|
|
|
switch (code1)
|
switch (code1)
|
{
|
{
|
case UNEQ:
|
case UNEQ:
|
if (code2 == UNLE || code2 == UNGE)
|
if (code2 == UNLE || code2 == UNGE)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case EQ:
|
case EQ:
|
if (code2 == LE || code2 == LEU || code2 == GE || code2 == GEU
|
if (code2 == LE || code2 == LEU || code2 == GE || code2 == GEU
|
|| code2 == ORDERED)
|
|| code2 == ORDERED)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case UNLT:
|
case UNLT:
|
if (code2 == UNLE || code2 == NE)
|
if (code2 == UNLE || code2 == NE)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case LT:
|
case LT:
|
if (code2 == LE || code2 == NE || code2 == ORDERED || code2 == LTGT)
|
if (code2 == LE || code2 == NE || code2 == ORDERED || code2 == LTGT)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case UNGT:
|
case UNGT:
|
if (code2 == UNGE || code2 == NE)
|
if (code2 == UNGE || code2 == NE)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case GT:
|
case GT:
|
if (code2 == GE || code2 == NE || code2 == ORDERED || code2 == LTGT)
|
if (code2 == GE || code2 == NE || code2 == ORDERED || code2 == LTGT)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case GE:
|
case GE:
|
case LE:
|
case LE:
|
if (code2 == ORDERED)
|
if (code2 == ORDERED)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case LTGT:
|
case LTGT:
|
if (code2 == NE || code2 == ORDERED)
|
if (code2 == NE || code2 == ORDERED)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case LTU:
|
case LTU:
|
if (code2 == LEU || code2 == NE)
|
if (code2 == LEU || code2 == NE)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case GTU:
|
case GTU:
|
if (code2 == GEU || code2 == NE)
|
if (code2 == GEU || code2 == NE)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case UNORDERED:
|
case UNORDERED:
|
if (code2 == NE || code2 == UNEQ || code2 == UNLE || code2 == UNLT
|
if (code2 == NE || code2 == UNEQ || code2 == UNLE || code2 == UNLT
|
|| code2 == UNGE || code2 == UNGT)
|
|| code2 == UNGE || code2 == UNGT)
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if INSN is an unconditional jump and nothing else. */
|
/* Return 1 if INSN is an unconditional jump and nothing else. */
|
|
|
int
|
int
|
simplejump_p (rtx insn)
|
simplejump_p (rtx insn)
|
{
|
{
|
return (JUMP_P (insn)
|
return (JUMP_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SET
|
&& GET_CODE (PATTERN (insn)) == SET
|
&& GET_CODE (SET_DEST (PATTERN (insn))) == PC
|
&& GET_CODE (SET_DEST (PATTERN (insn))) == PC
|
&& GET_CODE (SET_SRC (PATTERN (insn))) == LABEL_REF);
|
&& GET_CODE (SET_SRC (PATTERN (insn))) == LABEL_REF);
|
}
|
}
|
|
|
/* Return nonzero if INSN is a (possibly) conditional jump
|
/* Return nonzero if INSN is a (possibly) conditional jump
|
and nothing more.
|
and nothing more.
|
|
|
Use of this function is deprecated, since we need to support combined
|
Use of this function is deprecated, since we need to support combined
|
branch and compare insns. Use any_condjump_p instead whenever possible. */
|
branch and compare insns. Use any_condjump_p instead whenever possible. */
|
|
|
int
|
int
|
condjump_p (rtx insn)
|
condjump_p (rtx insn)
|
{
|
{
|
rtx x = PATTERN (insn);
|
rtx x = PATTERN (insn);
|
|
|
if (GET_CODE (x) != SET
|
if (GET_CODE (x) != SET
|
|| GET_CODE (SET_DEST (x)) != PC)
|
|| GET_CODE (SET_DEST (x)) != PC)
|
return 0;
|
return 0;
|
|
|
x = SET_SRC (x);
|
x = SET_SRC (x);
|
if (GET_CODE (x) == LABEL_REF)
|
if (GET_CODE (x) == LABEL_REF)
|
return 1;
|
return 1;
|
else
|
else
|
return (GET_CODE (x) == IF_THEN_ELSE
|
return (GET_CODE (x) == IF_THEN_ELSE
|
&& ((GET_CODE (XEXP (x, 2)) == PC
|
&& ((GET_CODE (XEXP (x, 2)) == PC
|
&& (GET_CODE (XEXP (x, 1)) == LABEL_REF
|
&& (GET_CODE (XEXP (x, 1)) == LABEL_REF
|
|| GET_CODE (XEXP (x, 1)) == RETURN))
|
|| GET_CODE (XEXP (x, 1)) == RETURN))
|
|| (GET_CODE (XEXP (x, 1)) == PC
|
|| (GET_CODE (XEXP (x, 1)) == PC
|
&& (GET_CODE (XEXP (x, 2)) == LABEL_REF
|
&& (GET_CODE (XEXP (x, 2)) == LABEL_REF
|
|| GET_CODE (XEXP (x, 2)) == RETURN))));
|
|| GET_CODE (XEXP (x, 2)) == RETURN))));
|
}
|
}
|
|
|
/* Return nonzero if INSN is a (possibly) conditional jump inside a
|
/* Return nonzero if INSN is a (possibly) conditional jump inside a
|
PARALLEL.
|
PARALLEL.
|
|
|
Use this function is deprecated, since we need to support combined
|
Use this function is deprecated, since we need to support combined
|
branch and compare insns. Use any_condjump_p instead whenever possible. */
|
branch and compare insns. Use any_condjump_p instead whenever possible. */
|
|
|
int
|
int
|
condjump_in_parallel_p (rtx insn)
|
condjump_in_parallel_p (rtx insn)
|
{
|
{
|
rtx x = PATTERN (insn);
|
rtx x = PATTERN (insn);
|
|
|
if (GET_CODE (x) != PARALLEL)
|
if (GET_CODE (x) != PARALLEL)
|
return 0;
|
return 0;
|
else
|
else
|
x = XVECEXP (x, 0, 0);
|
x = XVECEXP (x, 0, 0);
|
|
|
if (GET_CODE (x) != SET)
|
if (GET_CODE (x) != SET)
|
return 0;
|
return 0;
|
if (GET_CODE (SET_DEST (x)) != PC)
|
if (GET_CODE (SET_DEST (x)) != PC)
|
return 0;
|
return 0;
|
if (GET_CODE (SET_SRC (x)) == LABEL_REF)
|
if (GET_CODE (SET_SRC (x)) == LABEL_REF)
|
return 1;
|
return 1;
|
if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
|
if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
|
return 0;
|
return 0;
|
if (XEXP (SET_SRC (x), 2) == pc_rtx
|
if (XEXP (SET_SRC (x), 2) == pc_rtx
|
&& (GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF
|
&& (GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF
|
|| GET_CODE (XEXP (SET_SRC (x), 1)) == RETURN))
|
|| GET_CODE (XEXP (SET_SRC (x), 1)) == RETURN))
|
return 1;
|
return 1;
|
if (XEXP (SET_SRC (x), 1) == pc_rtx
|
if (XEXP (SET_SRC (x), 1) == pc_rtx
|
&& (GET_CODE (XEXP (SET_SRC (x), 2)) == LABEL_REF
|
&& (GET_CODE (XEXP (SET_SRC (x), 2)) == LABEL_REF
|
|| GET_CODE (XEXP (SET_SRC (x), 2)) == RETURN))
|
|| GET_CODE (XEXP (SET_SRC (x), 2)) == RETURN))
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return set of PC, otherwise NULL. */
|
/* Return set of PC, otherwise NULL. */
|
|
|
rtx
|
rtx
|
pc_set (rtx insn)
|
pc_set (rtx insn)
|
{
|
{
|
rtx pat;
|
rtx pat;
|
if (!JUMP_P (insn))
|
if (!JUMP_P (insn))
|
return NULL_RTX;
|
return NULL_RTX;
|
pat = PATTERN (insn);
|
pat = PATTERN (insn);
|
|
|
/* The set is allowed to appear either as the insn pattern or
|
/* The set is allowed to appear either as the insn pattern or
|
the first set in a PARALLEL. */
|
the first set in a PARALLEL. */
|
if (GET_CODE (pat) == PARALLEL)
|
if (GET_CODE (pat) == PARALLEL)
|
pat = XVECEXP (pat, 0, 0);
|
pat = XVECEXP (pat, 0, 0);
|
if (GET_CODE (pat) == SET && GET_CODE (SET_DEST (pat)) == PC)
|
if (GET_CODE (pat) == SET && GET_CODE (SET_DEST (pat)) == PC)
|
return pat;
|
return pat;
|
|
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* Return true when insn is an unconditional direct jump,
|
/* Return true when insn is an unconditional direct jump,
|
possibly bundled inside a PARALLEL. */
|
possibly bundled inside a PARALLEL. */
|
|
|
int
|
int
|
any_uncondjump_p (rtx insn)
|
any_uncondjump_p (rtx insn)
|
{
|
{
|
rtx x = pc_set (insn);
|
rtx x = pc_set (insn);
|
if (!x)
|
if (!x)
|
return 0;
|
return 0;
|
if (GET_CODE (SET_SRC (x)) != LABEL_REF)
|
if (GET_CODE (SET_SRC (x)) != LABEL_REF)
|
return 0;
|
return 0;
|
if (find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX))
|
if (find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX))
|
return 0;
|
return 0;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Return true when insn is a conditional jump. This function works for
|
/* Return true when insn is a conditional jump. This function works for
|
instructions containing PC sets in PARALLELs. The instruction may have
|
instructions containing PC sets in PARALLELs. The instruction may have
|
various other effects so before removing the jump you must verify
|
various other effects so before removing the jump you must verify
|
onlyjump_p.
|
onlyjump_p.
|
|
|
Note that unlike condjump_p it returns false for unconditional jumps. */
|
Note that unlike condjump_p it returns false for unconditional jumps. */
|
|
|
int
|
int
|
any_condjump_p (rtx insn)
|
any_condjump_p (rtx insn)
|
{
|
{
|
rtx x = pc_set (insn);
|
rtx x = pc_set (insn);
|
enum rtx_code a, b;
|
enum rtx_code a, b;
|
|
|
if (!x)
|
if (!x)
|
return 0;
|
return 0;
|
if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
|
if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
|
return 0;
|
return 0;
|
|
|
a = GET_CODE (XEXP (SET_SRC (x), 1));
|
a = GET_CODE (XEXP (SET_SRC (x), 1));
|
b = GET_CODE (XEXP (SET_SRC (x), 2));
|
b = GET_CODE (XEXP (SET_SRC (x), 2));
|
|
|
return ((b == PC && (a == LABEL_REF || a == RETURN))
|
return ((b == PC && (a == LABEL_REF || a == RETURN))
|
|| (a == PC && (b == LABEL_REF || b == RETURN)));
|
|| (a == PC && (b == LABEL_REF || b == RETURN)));
|
}
|
}
|
|
|
/* Return the label of a conditional jump. */
|
/* Return the label of a conditional jump. */
|
|
|
rtx
|
rtx
|
condjump_label (rtx insn)
|
condjump_label (rtx insn)
|
{
|
{
|
rtx x = pc_set (insn);
|
rtx x = pc_set (insn);
|
|
|
if (!x)
|
if (!x)
|
return NULL_RTX;
|
return NULL_RTX;
|
x = SET_SRC (x);
|
x = SET_SRC (x);
|
if (GET_CODE (x) == LABEL_REF)
|
if (GET_CODE (x) == LABEL_REF)
|
return x;
|
return x;
|
if (GET_CODE (x) != IF_THEN_ELSE)
|
if (GET_CODE (x) != IF_THEN_ELSE)
|
return NULL_RTX;
|
return NULL_RTX;
|
if (XEXP (x, 2) == pc_rtx && GET_CODE (XEXP (x, 1)) == LABEL_REF)
|
if (XEXP (x, 2) == pc_rtx && GET_CODE (XEXP (x, 1)) == LABEL_REF)
|
return XEXP (x, 1);
|
return XEXP (x, 1);
|
if (XEXP (x, 1) == pc_rtx && GET_CODE (XEXP (x, 2)) == LABEL_REF)
|
if (XEXP (x, 1) == pc_rtx && GET_CODE (XEXP (x, 2)) == LABEL_REF)
|
return XEXP (x, 2);
|
return XEXP (x, 2);
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* Return true if INSN is a (possibly conditional) return insn. */
|
/* Return true if INSN is a (possibly conditional) return insn. */
|
|
|
static int
|
static int
|
returnjump_p_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
|
returnjump_p_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
rtx x = *loc;
|
rtx x = *loc;
|
|
|
return x && (GET_CODE (x) == RETURN
|
return x && (GET_CODE (x) == RETURN
|
|| (GET_CODE (x) == SET && SET_IS_RETURN_P (x)));
|
|| (GET_CODE (x) == SET && SET_IS_RETURN_P (x)));
|
}
|
}
|
|
|
int
|
int
|
returnjump_p (rtx insn)
|
returnjump_p (rtx insn)
|
{
|
{
|
if (!JUMP_P (insn))
|
if (!JUMP_P (insn))
|
return 0;
|
return 0;
|
return for_each_rtx (&PATTERN (insn), returnjump_p_1, NULL);
|
return for_each_rtx (&PATTERN (insn), returnjump_p_1, NULL);
|
}
|
}
|
|
|
/* Return true if INSN is a jump that only transfers control and
|
/* Return true if INSN is a jump that only transfers control and
|
nothing more. */
|
nothing more. */
|
|
|
int
|
int
|
onlyjump_p (rtx insn)
|
onlyjump_p (rtx insn)
|
{
|
{
|
rtx set;
|
rtx set;
|
|
|
if (!JUMP_P (insn))
|
if (!JUMP_P (insn))
|
return 0;
|
return 0;
|
|
|
set = single_set (insn);
|
set = single_set (insn);
|
if (set == NULL)
|
if (set == NULL)
|
return 0;
|
return 0;
|
if (GET_CODE (SET_DEST (set)) != PC)
|
if (GET_CODE (SET_DEST (set)) != PC)
|
return 0;
|
return 0;
|
if (side_effects_p (SET_SRC (set)))
|
if (side_effects_p (SET_SRC (set)))
|
return 0;
|
return 0;
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
|
|
/* Return nonzero if X is an RTX that only sets the condition codes
|
/* Return nonzero if X is an RTX that only sets the condition codes
|
and has no side effects. */
|
and has no side effects. */
|
|
|
int
|
int
|
only_sets_cc0_p (rtx x)
|
only_sets_cc0_p (rtx x)
|
{
|
{
|
if (! x)
|
if (! x)
|
return 0;
|
return 0;
|
|
|
if (INSN_P (x))
|
if (INSN_P (x))
|
x = PATTERN (x);
|
x = PATTERN (x);
|
|
|
return sets_cc0_p (x) == 1 && ! side_effects_p (x);
|
return sets_cc0_p (x) == 1 && ! side_effects_p (x);
|
}
|
}
|
|
|
/* Return 1 if X is an RTX that does nothing but set the condition codes
|
/* Return 1 if X is an RTX that does nothing but set the condition codes
|
and CLOBBER or USE registers.
|
and CLOBBER or USE registers.
|
Return -1 if X does explicitly set the condition codes,
|
Return -1 if X does explicitly set the condition codes,
|
but also does other things. */
|
but also does other things. */
|
|
|
int
|
int
|
sets_cc0_p (rtx x)
|
sets_cc0_p (rtx x)
|
{
|
{
|
if (! x)
|
if (! x)
|
return 0;
|
return 0;
|
|
|
if (INSN_P (x))
|
if (INSN_P (x))
|
x = PATTERN (x);
|
x = PATTERN (x);
|
|
|
if (GET_CODE (x) == SET && SET_DEST (x) == cc0_rtx)
|
if (GET_CODE (x) == SET && SET_DEST (x) == cc0_rtx)
|
return 1;
|
return 1;
|
if (GET_CODE (x) == PARALLEL)
|
if (GET_CODE (x) == PARALLEL)
|
{
|
{
|
int i;
|
int i;
|
int sets_cc0 = 0;
|
int sets_cc0 = 0;
|
int other_things = 0;
|
int other_things = 0;
|
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
|
{
|
{
|
if (GET_CODE (XVECEXP (x, 0, i)) == SET
|
if (GET_CODE (XVECEXP (x, 0, i)) == SET
|
&& SET_DEST (XVECEXP (x, 0, i)) == cc0_rtx)
|
&& SET_DEST (XVECEXP (x, 0, i)) == cc0_rtx)
|
sets_cc0 = 1;
|
sets_cc0 = 1;
|
else if (GET_CODE (XVECEXP (x, 0, i)) == SET)
|
else if (GET_CODE (XVECEXP (x, 0, i)) == SET)
|
other_things = 1;
|
other_things = 1;
|
}
|
}
|
return ! sets_cc0 ? 0 : other_things ? -1 : 1;
|
return ! sets_cc0 ? 0 : other_things ? -1 : 1;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* Follow any unconditional jump at LABEL;
|
/* Follow any unconditional jump at LABEL;
|
return the ultimate label reached by any such chain of jumps.
|
return the ultimate label reached by any such chain of jumps.
|
Return null if the chain ultimately leads to a return instruction.
|
Return null if the chain ultimately leads to a return instruction.
|
If LABEL is not followed by a jump, return LABEL.
|
If LABEL is not followed by a jump, return LABEL.
|
If the chain loops or we can't find end, return LABEL,
|
If the chain loops or we can't find end, return LABEL,
|
since that tells caller to avoid changing the insn.
|
since that tells caller to avoid changing the insn.
|
|
|
If RELOAD_COMPLETED is 0, we do not chain across a USE or CLOBBER. */
|
If RELOAD_COMPLETED is 0, we do not chain across a USE or CLOBBER. */
|
|
|
rtx
|
rtx
|
follow_jumps (rtx label)
|
follow_jumps (rtx label)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
rtx next;
|
rtx next;
|
rtx value = label;
|
rtx value = label;
|
int depth;
|
int depth;
|
|
|
for (depth = 0;
|
for (depth = 0;
|
(depth < 10
|
(depth < 10
|
&& (insn = next_active_insn (value)) != 0
|
&& (insn = next_active_insn (value)) != 0
|
&& JUMP_P (insn)
|
&& JUMP_P (insn)
|
&& ((JUMP_LABEL (insn) != 0 && any_uncondjump_p (insn)
|
&& ((JUMP_LABEL (insn) != 0 && any_uncondjump_p (insn)
|
&& onlyjump_p (insn))
|
&& onlyjump_p (insn))
|
|| GET_CODE (PATTERN (insn)) == RETURN)
|
|| GET_CODE (PATTERN (insn)) == RETURN)
|
&& (next = NEXT_INSN (insn))
|
&& (next = NEXT_INSN (insn))
|
&& BARRIER_P (next));
|
&& BARRIER_P (next));
|
depth++)
|
depth++)
|
{
|
{
|
rtx tem;
|
rtx tem;
|
if (!reload_completed && flag_test_coverage)
|
if (!reload_completed && flag_test_coverage)
|
{
|
{
|
/* ??? Optional. Disables some optimizations, but makes
|
/* ??? Optional. Disables some optimizations, but makes
|
gcov output more accurate with -O. */
|
gcov output more accurate with -O. */
|
for (tem = value; tem != insn; tem = NEXT_INSN (tem))
|
for (tem = value; tem != insn; tem = NEXT_INSN (tem))
|
if (NOTE_P (tem) && NOTE_LINE_NUMBER (tem) > 0)
|
if (NOTE_P (tem) && NOTE_LINE_NUMBER (tem) > 0)
|
return value;
|
return value;
|
}
|
}
|
|
|
/* If we have found a cycle, make the insn jump to itself. */
|
/* If we have found a cycle, make the insn jump to itself. */
|
if (JUMP_LABEL (insn) == label)
|
if (JUMP_LABEL (insn) == label)
|
return label;
|
return label;
|
|
|
tem = next_active_insn (JUMP_LABEL (insn));
|
tem = next_active_insn (JUMP_LABEL (insn));
|
if (tem && (GET_CODE (PATTERN (tem)) == ADDR_VEC
|
if (tem && (GET_CODE (PATTERN (tem)) == ADDR_VEC
|
|| GET_CODE (PATTERN (tem)) == ADDR_DIFF_VEC))
|
|| GET_CODE (PATTERN (tem)) == ADDR_DIFF_VEC))
|
break;
|
break;
|
|
|
value = JUMP_LABEL (insn);
|
value = JUMP_LABEL (insn);
|
}
|
}
|
if (depth == 10)
|
if (depth == 10)
|
return label;
|
return label;
|
return value;
|
return value;
|
}
|
}
|
|
|
|
|
/* Find all CODE_LABELs referred to in X, and increment their use counts.
|
/* Find all CODE_LABELs referred to in X, and increment their use counts.
|
If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
|
If INSN is a JUMP_INSN and there is at least one CODE_LABEL referenced
|
in INSN, then store one of them in JUMP_LABEL (INSN).
|
in INSN, then store one of them in JUMP_LABEL (INSN).
|
If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
|
If INSN is an INSN or a CALL_INSN and there is at least one CODE_LABEL
|
referenced in INSN, add a REG_LABEL note containing that label to INSN.
|
referenced in INSN, add a REG_LABEL note containing that label to INSN.
|
Also, when there are consecutive labels, canonicalize on the last of them.
|
Also, when there are consecutive labels, canonicalize on the last of them.
|
|
|
Note that two labels separated by a loop-beginning note
|
Note that two labels separated by a loop-beginning note
|
must be kept distinct if we have not yet done loop-optimization,
|
must be kept distinct if we have not yet done loop-optimization,
|
because the gap between them is where loop-optimize
|
because the gap between them is where loop-optimize
|
will want to move invariant code to. CROSS_JUMP tells us
|
will want to move invariant code to. CROSS_JUMP tells us
|
that loop-optimization is done with. */
|
that loop-optimization is done with. */
|
|
|
void
|
void
|
mark_jump_label (rtx x, rtx insn, int in_mem)
|
mark_jump_label (rtx x, rtx insn, int in_mem)
|
{
|
{
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
int i;
|
int i;
|
const char *fmt;
|
const char *fmt;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
case REG:
|
case REG:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CLOBBER:
|
case CLOBBER:
|
case CALL:
|
case CALL:
|
return;
|
return;
|
|
|
case MEM:
|
case MEM:
|
in_mem = 1;
|
in_mem = 1;
|
break;
|
break;
|
|
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
if (!in_mem)
|
if (!in_mem)
|
return;
|
return;
|
|
|
/* If this is a constant-pool reference, see if it is a label. */
|
/* If this is a constant-pool reference, see if it is a label. */
|
if (CONSTANT_POOL_ADDRESS_P (x))
|
if (CONSTANT_POOL_ADDRESS_P (x))
|
mark_jump_label (get_pool_constant (x), insn, in_mem);
|
mark_jump_label (get_pool_constant (x), insn, in_mem);
|
break;
|
break;
|
|
|
case LABEL_REF:
|
case LABEL_REF:
|
{
|
{
|
rtx label = XEXP (x, 0);
|
rtx label = XEXP (x, 0);
|
|
|
/* Ignore remaining references to unreachable labels that
|
/* Ignore remaining references to unreachable labels that
|
have been deleted. */
|
have been deleted. */
|
if (NOTE_P (label)
|
if (NOTE_P (label)
|
&& NOTE_LINE_NUMBER (label) == NOTE_INSN_DELETED_LABEL)
|
&& NOTE_LINE_NUMBER (label) == NOTE_INSN_DELETED_LABEL)
|
break;
|
break;
|
|
|
gcc_assert (LABEL_P (label));
|
gcc_assert (LABEL_P (label));
|
|
|
/* Ignore references to labels of containing functions. */
|
/* Ignore references to labels of containing functions. */
|
if (LABEL_REF_NONLOCAL_P (x))
|
if (LABEL_REF_NONLOCAL_P (x))
|
break;
|
break;
|
|
|
XEXP (x, 0) = label;
|
XEXP (x, 0) = label;
|
if (! insn || ! INSN_DELETED_P (insn))
|
if (! insn || ! INSN_DELETED_P (insn))
|
++LABEL_NUSES (label);
|
++LABEL_NUSES (label);
|
|
|
if (insn)
|
if (insn)
|
{
|
{
|
if (JUMP_P (insn))
|
if (JUMP_P (insn))
|
JUMP_LABEL (insn) = label;
|
JUMP_LABEL (insn) = label;
|
else
|
else
|
{
|
{
|
/* Add a REG_LABEL note for LABEL unless there already
|
/* Add a REG_LABEL note for LABEL unless there already
|
is one. All uses of a label, except for labels
|
is one. All uses of a label, except for labels
|
that are the targets of jumps, must have a
|
that are the targets of jumps, must have a
|
REG_LABEL note. */
|
REG_LABEL note. */
|
if (! find_reg_note (insn, REG_LABEL, label))
|
if (! find_reg_note (insn, REG_LABEL, label))
|
REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL, label,
|
REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL, label,
|
REG_NOTES (insn));
|
REG_NOTES (insn));
|
}
|
}
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
/* Do walk the labels in a vector, but not the first operand of an
|
/* Do walk the labels in a vector, but not the first operand of an
|
ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
|
ADDR_DIFF_VEC. Don't set the JUMP_LABEL of a vector. */
|
case ADDR_VEC:
|
case ADDR_VEC:
|
case ADDR_DIFF_VEC:
|
case ADDR_DIFF_VEC:
|
if (! INSN_DELETED_P (insn))
|
if (! INSN_DELETED_P (insn))
|
{
|
{
|
int eltnum = code == ADDR_DIFF_VEC ? 1 : 0;
|
int eltnum = code == ADDR_DIFF_VEC ? 1 : 0;
|
|
|
for (i = 0; i < XVECLEN (x, eltnum); i++)
|
for (i = 0; i < XVECLEN (x, eltnum); i++)
|
mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX, in_mem);
|
mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX, in_mem);
|
}
|
}
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
mark_jump_label (XEXP (x, i), insn, in_mem);
|
mark_jump_label (XEXP (x, i), insn, in_mem);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
mark_jump_label (XVECEXP (x, i, j), insn, in_mem);
|
mark_jump_label (XVECEXP (x, i, j), insn, in_mem);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* If all INSN does is set the pc, delete it,
|
/* If all INSN does is set the pc, delete it,
|
and delete the insn that set the condition codes for it
|
and delete the insn that set the condition codes for it
|
if that's what the previous thing was. */
|
if that's what the previous thing was. */
|
|
|
void
|
void
|
delete_jump (rtx insn)
|
delete_jump (rtx insn)
|
{
|
{
|
rtx set = single_set (insn);
|
rtx set = single_set (insn);
|
|
|
if (set && GET_CODE (SET_DEST (set)) == PC)
|
if (set && GET_CODE (SET_DEST (set)) == PC)
|
delete_computation (insn);
|
delete_computation (insn);
|
}
|
}
|
|
|
/* Recursively delete prior insns that compute the value (used only by INSN
|
/* Recursively delete prior insns that compute the value (used only by INSN
|
which the caller is deleting) stored in the register mentioned by NOTE
|
which the caller is deleting) stored in the register mentioned by NOTE
|
which is a REG_DEAD note associated with INSN. */
|
which is a REG_DEAD note associated with INSN. */
|
|
|
static void
|
static void
|
delete_prior_computation (rtx note, rtx insn)
|
delete_prior_computation (rtx note, rtx insn)
|
{
|
{
|
rtx our_prev;
|
rtx our_prev;
|
rtx reg = XEXP (note, 0);
|
rtx reg = XEXP (note, 0);
|
|
|
for (our_prev = prev_nonnote_insn (insn);
|
for (our_prev = prev_nonnote_insn (insn);
|
our_prev && (NONJUMP_INSN_P (our_prev)
|
our_prev && (NONJUMP_INSN_P (our_prev)
|
|| CALL_P (our_prev));
|
|| CALL_P (our_prev));
|
our_prev = prev_nonnote_insn (our_prev))
|
our_prev = prev_nonnote_insn (our_prev))
|
{
|
{
|
rtx pat = PATTERN (our_prev);
|
rtx pat = PATTERN (our_prev);
|
|
|
/* If we reach a CALL which is not calling a const function
|
/* If we reach a CALL which is not calling a const function
|
or the callee pops the arguments, then give up. */
|
or the callee pops the arguments, then give up. */
|
if (CALL_P (our_prev)
|
if (CALL_P (our_prev)
|
&& (! CONST_OR_PURE_CALL_P (our_prev)
|
&& (! CONST_OR_PURE_CALL_P (our_prev)
|
|| GET_CODE (pat) != SET || GET_CODE (SET_SRC (pat)) != CALL))
|
|| GET_CODE (pat) != SET || GET_CODE (SET_SRC (pat)) != CALL))
|
break;
|
break;
|
|
|
/* If we reach a SEQUENCE, it is too complex to try to
|
/* If we reach a SEQUENCE, it is too complex to try to
|
do anything with it, so give up. We can be run during
|
do anything with it, so give up. We can be run during
|
and after reorg, so SEQUENCE rtl can legitimately show
|
and after reorg, so SEQUENCE rtl can legitimately show
|
up here. */
|
up here. */
|
if (GET_CODE (pat) == SEQUENCE)
|
if (GET_CODE (pat) == SEQUENCE)
|
break;
|
break;
|
|
|
if (GET_CODE (pat) == USE
|
if (GET_CODE (pat) == USE
|
&& NONJUMP_INSN_P (XEXP (pat, 0)))
|
&& NONJUMP_INSN_P (XEXP (pat, 0)))
|
/* reorg creates USEs that look like this. We leave them
|
/* reorg creates USEs that look like this. We leave them
|
alone because reorg needs them for its own purposes. */
|
alone because reorg needs them for its own purposes. */
|
break;
|
break;
|
|
|
if (reg_set_p (reg, pat))
|
if (reg_set_p (reg, pat))
|
{
|
{
|
if (side_effects_p (pat) && !CALL_P (our_prev))
|
if (side_effects_p (pat) && !CALL_P (our_prev))
|
break;
|
break;
|
|
|
if (GET_CODE (pat) == PARALLEL)
|
if (GET_CODE (pat) == PARALLEL)
|
{
|
{
|
/* If we find a SET of something else, we can't
|
/* If we find a SET of something else, we can't
|
delete the insn. */
|
delete the insn. */
|
|
|
int i;
|
int i;
|
|
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
for (i = 0; i < XVECLEN (pat, 0); i++)
|
{
|
{
|
rtx part = XVECEXP (pat, 0, i);
|
rtx part = XVECEXP (pat, 0, i);
|
|
|
if (GET_CODE (part) == SET
|
if (GET_CODE (part) == SET
|
&& SET_DEST (part) != reg)
|
&& SET_DEST (part) != reg)
|
break;
|
break;
|
}
|
}
|
|
|
if (i == XVECLEN (pat, 0))
|
if (i == XVECLEN (pat, 0))
|
delete_computation (our_prev);
|
delete_computation (our_prev);
|
}
|
}
|
else if (GET_CODE (pat) == SET
|
else if (GET_CODE (pat) == SET
|
&& REG_P (SET_DEST (pat)))
|
&& REG_P (SET_DEST (pat)))
|
{
|
{
|
int dest_regno = REGNO (SET_DEST (pat));
|
int dest_regno = REGNO (SET_DEST (pat));
|
int dest_endregno
|
int dest_endregno
|
= (dest_regno
|
= (dest_regno
|
+ (dest_regno < FIRST_PSEUDO_REGISTER
|
+ (dest_regno < FIRST_PSEUDO_REGISTER
|
? hard_regno_nregs[dest_regno]
|
? hard_regno_nregs[dest_regno]
|
[GET_MODE (SET_DEST (pat))] : 1));
|
[GET_MODE (SET_DEST (pat))] : 1));
|
int regno = REGNO (reg);
|
int regno = REGNO (reg);
|
int endregno
|
int endregno
|
= (regno
|
= (regno
|
+ (regno < FIRST_PSEUDO_REGISTER
|
+ (regno < FIRST_PSEUDO_REGISTER
|
? hard_regno_nregs[regno][GET_MODE (reg)] : 1));
|
? hard_regno_nregs[regno][GET_MODE (reg)] : 1));
|
|
|
if (dest_regno >= regno
|
if (dest_regno >= regno
|
&& dest_endregno <= endregno)
|
&& dest_endregno <= endregno)
|
delete_computation (our_prev);
|
delete_computation (our_prev);
|
|
|
/* We may have a multi-word hard register and some, but not
|
/* We may have a multi-word hard register and some, but not
|
all, of the words of the register are needed in subsequent
|
all, of the words of the register are needed in subsequent
|
insns. Write REG_UNUSED notes for those parts that were not
|
insns. Write REG_UNUSED notes for those parts that were not
|
needed. */
|
needed. */
|
else if (dest_regno <= regno
|
else if (dest_regno <= regno
|
&& dest_endregno >= endregno)
|
&& dest_endregno >= endregno)
|
{
|
{
|
int i;
|
int i;
|
|
|
REG_NOTES (our_prev)
|
REG_NOTES (our_prev)
|
= gen_rtx_EXPR_LIST (REG_UNUSED, reg,
|
= gen_rtx_EXPR_LIST (REG_UNUSED, reg,
|
REG_NOTES (our_prev));
|
REG_NOTES (our_prev));
|
|
|
for (i = dest_regno; i < dest_endregno; i++)
|
for (i = dest_regno; i < dest_endregno; i++)
|
if (! find_regno_note (our_prev, REG_UNUSED, i))
|
if (! find_regno_note (our_prev, REG_UNUSED, i))
|
break;
|
break;
|
|
|
if (i == dest_endregno)
|
if (i == dest_endregno)
|
delete_computation (our_prev);
|
delete_computation (our_prev);
|
}
|
}
|
}
|
}
|
|
|
break;
|
break;
|
}
|
}
|
|
|
/* If PAT references the register that dies here, it is an
|
/* If PAT references the register that dies here, it is an
|
additional use. Hence any prior SET isn't dead. However, this
|
additional use. Hence any prior SET isn't dead. However, this
|
insn becomes the new place for the REG_DEAD note. */
|
insn becomes the new place for the REG_DEAD note. */
|
if (reg_overlap_mentioned_p (reg, pat))
|
if (reg_overlap_mentioned_p (reg, pat))
|
{
|
{
|
XEXP (note, 1) = REG_NOTES (our_prev);
|
XEXP (note, 1) = REG_NOTES (our_prev);
|
REG_NOTES (our_prev) = note;
|
REG_NOTES (our_prev) = note;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Delete INSN and recursively delete insns that compute values used only
|
/* Delete INSN and recursively delete insns that compute values used only
|
by INSN. This uses the REG_DEAD notes computed during flow analysis.
|
by INSN. This uses the REG_DEAD notes computed during flow analysis.
|
If we are running before flow.c, we need do nothing since flow.c will
|
If we are running before flow.c, we need do nothing since flow.c will
|
delete dead code. We also can't know if the registers being used are
|
delete dead code. We also can't know if the registers being used are
|
dead or not at this point.
|
dead or not at this point.
|
|
|
Otherwise, look at all our REG_DEAD notes. If a previous insn does
|
Otherwise, look at all our REG_DEAD notes. If a previous insn does
|
nothing other than set a register that dies in this insn, we can delete
|
nothing other than set a register that dies in this insn, we can delete
|
that insn as well.
|
that insn as well.
|
|
|
On machines with CC0, if CC0 is used in this insn, we may be able to
|
On machines with CC0, if CC0 is used in this insn, we may be able to
|
delete the insn that set it. */
|
delete the insn that set it. */
|
|
|
static void
|
static void
|
delete_computation (rtx insn)
|
delete_computation (rtx insn)
|
{
|
{
|
rtx note, next;
|
rtx note, next;
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
|
if (reg_referenced_p (cc0_rtx, PATTERN (insn)))
|
{
|
{
|
rtx prev = prev_nonnote_insn (insn);
|
rtx prev = prev_nonnote_insn (insn);
|
/* We assume that at this stage
|
/* We assume that at this stage
|
CC's are always set explicitly
|
CC's are always set explicitly
|
and always immediately before the jump that
|
and always immediately before the jump that
|
will use them. So if the previous insn
|
will use them. So if the previous insn
|
exists to set the CC's, delete it
|
exists to set the CC's, delete it
|
(unless it performs auto-increments, etc.). */
|
(unless it performs auto-increments, etc.). */
|
if (prev && NONJUMP_INSN_P (prev)
|
if (prev && NONJUMP_INSN_P (prev)
|
&& sets_cc0_p (PATTERN (prev)))
|
&& sets_cc0_p (PATTERN (prev)))
|
{
|
{
|
if (sets_cc0_p (PATTERN (prev)) > 0
|
if (sets_cc0_p (PATTERN (prev)) > 0
|
&& ! side_effects_p (PATTERN (prev)))
|
&& ! side_effects_p (PATTERN (prev)))
|
delete_computation (prev);
|
delete_computation (prev);
|
else
|
else
|
/* Otherwise, show that cc0 won't be used. */
|
/* Otherwise, show that cc0 won't be used. */
|
REG_NOTES (prev) = gen_rtx_EXPR_LIST (REG_UNUSED,
|
REG_NOTES (prev) = gen_rtx_EXPR_LIST (REG_UNUSED,
|
cc0_rtx, REG_NOTES (prev));
|
cc0_rtx, REG_NOTES (prev));
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
|
|
for (note = REG_NOTES (insn); note; note = next)
|
for (note = REG_NOTES (insn); note; note = next)
|
{
|
{
|
next = XEXP (note, 1);
|
next = XEXP (note, 1);
|
|
|
if (REG_NOTE_KIND (note) != REG_DEAD
|
if (REG_NOTE_KIND (note) != REG_DEAD
|
/* Verify that the REG_NOTE is legitimate. */
|
/* Verify that the REG_NOTE is legitimate. */
|
|| !REG_P (XEXP (note, 0)))
|
|| !REG_P (XEXP (note, 0)))
|
continue;
|
continue;
|
|
|
delete_prior_computation (note, insn);
|
delete_prior_computation (note, insn);
|
}
|
}
|
|
|
delete_related_insns (insn);
|
delete_related_insns (insn);
|
}
|
}
|
|
|
/* Delete insn INSN from the chain of insns and update label ref counts
|
/* Delete insn INSN from the chain of insns and update label ref counts
|
and delete insns now unreachable.
|
and delete insns now unreachable.
|
|
|
Returns the first insn after INSN that was not deleted.
|
Returns the first insn after INSN that was not deleted.
|
|
|
Usage of this instruction is deprecated. Use delete_insn instead and
|
Usage of this instruction is deprecated. Use delete_insn instead and
|
subsequent cfg_cleanup pass to delete unreachable code if needed. */
|
subsequent cfg_cleanup pass to delete unreachable code if needed. */
|
|
|
rtx
|
rtx
|
delete_related_insns (rtx insn)
|
delete_related_insns (rtx insn)
|
{
|
{
|
int was_code_label = (LABEL_P (insn));
|
int was_code_label = (LABEL_P (insn));
|
rtx note;
|
rtx note;
|
rtx next = NEXT_INSN (insn), prev = PREV_INSN (insn);
|
rtx next = NEXT_INSN (insn), prev = PREV_INSN (insn);
|
|
|
while (next && INSN_DELETED_P (next))
|
while (next && INSN_DELETED_P (next))
|
next = NEXT_INSN (next);
|
next = NEXT_INSN (next);
|
|
|
/* This insn is already deleted => return first following nondeleted. */
|
/* This insn is already deleted => return first following nondeleted. */
|
if (INSN_DELETED_P (insn))
|
if (INSN_DELETED_P (insn))
|
return next;
|
return next;
|
|
|
delete_insn (insn);
|
delete_insn (insn);
|
|
|
/* If instruction is followed by a barrier,
|
/* If instruction is followed by a barrier,
|
delete the barrier too. */
|
delete the barrier too. */
|
|
|
if (next != 0 && BARRIER_P (next))
|
if (next != 0 && BARRIER_P (next))
|
delete_insn (next);
|
delete_insn (next);
|
|
|
/* If deleting a jump, decrement the count of the label,
|
/* If deleting a jump, decrement the count of the label,
|
and delete the label if it is now unused. */
|
and delete the label if it is now unused. */
|
|
|
if (JUMP_P (insn) && JUMP_LABEL (insn))
|
if (JUMP_P (insn) && JUMP_LABEL (insn))
|
{
|
{
|
rtx lab = JUMP_LABEL (insn), lab_next;
|
rtx lab = JUMP_LABEL (insn), lab_next;
|
|
|
if (LABEL_NUSES (lab) == 0)
|
if (LABEL_NUSES (lab) == 0)
|
{
|
{
|
/* This can delete NEXT or PREV,
|
/* This can delete NEXT or PREV,
|
either directly if NEXT is JUMP_LABEL (INSN),
|
either directly if NEXT is JUMP_LABEL (INSN),
|
or indirectly through more levels of jumps. */
|
or indirectly through more levels of jumps. */
|
delete_related_insns (lab);
|
delete_related_insns (lab);
|
|
|
/* I feel a little doubtful about this loop,
|
/* I feel a little doubtful about this loop,
|
but I see no clean and sure alternative way
|
but I see no clean and sure alternative way
|
to find the first insn after INSN that is not now deleted.
|
to find the first insn after INSN that is not now deleted.
|
I hope this works. */
|
I hope this works. */
|
while (next && INSN_DELETED_P (next))
|
while (next && INSN_DELETED_P (next))
|
next = NEXT_INSN (next);
|
next = NEXT_INSN (next);
|
return next;
|
return next;
|
}
|
}
|
else if (tablejump_p (insn, NULL, &lab_next))
|
else if (tablejump_p (insn, NULL, &lab_next))
|
{
|
{
|
/* If we're deleting the tablejump, delete the dispatch table.
|
/* If we're deleting the tablejump, delete the dispatch table.
|
We may not be able to kill the label immediately preceding
|
We may not be able to kill the label immediately preceding
|
just yet, as it might be referenced in code leading up to
|
just yet, as it might be referenced in code leading up to
|
the tablejump. */
|
the tablejump. */
|
delete_related_insns (lab_next);
|
delete_related_insns (lab_next);
|
}
|
}
|
}
|
}
|
|
|
/* Likewise if we're deleting a dispatch table. */
|
/* Likewise if we're deleting a dispatch table. */
|
|
|
if (JUMP_P (insn)
|
if (JUMP_P (insn)
|
&& (GET_CODE (PATTERN (insn)) == ADDR_VEC
|
&& (GET_CODE (PATTERN (insn)) == ADDR_VEC
|
|| GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))
|
|| GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC))
|
{
|
{
|
rtx pat = PATTERN (insn);
|
rtx pat = PATTERN (insn);
|
int i, diff_vec_p = GET_CODE (pat) == ADDR_DIFF_VEC;
|
int i, diff_vec_p = GET_CODE (pat) == ADDR_DIFF_VEC;
|
int len = XVECLEN (pat, diff_vec_p);
|
int len = XVECLEN (pat, diff_vec_p);
|
|
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
if (LABEL_NUSES (XEXP (XVECEXP (pat, diff_vec_p, i), 0)) == 0)
|
if (LABEL_NUSES (XEXP (XVECEXP (pat, diff_vec_p, i), 0)) == 0)
|
delete_related_insns (XEXP (XVECEXP (pat, diff_vec_p, i), 0));
|
delete_related_insns (XEXP (XVECEXP (pat, diff_vec_p, i), 0));
|
while (next && INSN_DELETED_P (next))
|
while (next && INSN_DELETED_P (next))
|
next = NEXT_INSN (next);
|
next = NEXT_INSN (next);
|
return next;
|
return next;
|
}
|
}
|
|
|
/* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
|
/* Likewise for an ordinary INSN / CALL_INSN with a REG_LABEL note. */
|
if (NONJUMP_INSN_P (insn) || CALL_P (insn))
|
if (NONJUMP_INSN_P (insn) || CALL_P (insn))
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == REG_LABEL
|
if (REG_NOTE_KIND (note) == REG_LABEL
|
/* This could also be a NOTE_INSN_DELETED_LABEL note. */
|
/* This could also be a NOTE_INSN_DELETED_LABEL note. */
|
&& LABEL_P (XEXP (note, 0)))
|
&& LABEL_P (XEXP (note, 0)))
|
if (LABEL_NUSES (XEXP (note, 0)) == 0)
|
if (LABEL_NUSES (XEXP (note, 0)) == 0)
|
delete_related_insns (XEXP (note, 0));
|
delete_related_insns (XEXP (note, 0));
|
|
|
while (prev && (INSN_DELETED_P (prev) || NOTE_P (prev)))
|
while (prev && (INSN_DELETED_P (prev) || NOTE_P (prev)))
|
prev = PREV_INSN (prev);
|
prev = PREV_INSN (prev);
|
|
|
/* If INSN was a label and a dispatch table follows it,
|
/* If INSN was a label and a dispatch table follows it,
|
delete the dispatch table. The tablejump must have gone already.
|
delete the dispatch table. The tablejump must have gone already.
|
It isn't useful to fall through into a table. */
|
It isn't useful to fall through into a table. */
|
|
|
if (was_code_label
|
if (was_code_label
|
&& NEXT_INSN (insn) != 0
|
&& NEXT_INSN (insn) != 0
|
&& JUMP_P (NEXT_INSN (insn))
|
&& JUMP_P (NEXT_INSN (insn))
|
&& (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC
|
&& (GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_VEC
|
|| GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_DIFF_VEC))
|
|| GET_CODE (PATTERN (NEXT_INSN (insn))) == ADDR_DIFF_VEC))
|
next = delete_related_insns (NEXT_INSN (insn));
|
next = delete_related_insns (NEXT_INSN (insn));
|
|
|
/* If INSN was a label, delete insns following it if now unreachable. */
|
/* If INSN was a label, delete insns following it if now unreachable. */
|
|
|
if (was_code_label && prev && BARRIER_P (prev))
|
if (was_code_label && prev && BARRIER_P (prev))
|
{
|
{
|
enum rtx_code code;
|
enum rtx_code code;
|
while (next)
|
while (next)
|
{
|
{
|
code = GET_CODE (next);
|
code = GET_CODE (next);
|
if (code == NOTE
|
if (code == NOTE
|
&& NOTE_LINE_NUMBER (next) != NOTE_INSN_FUNCTION_END)
|
&& NOTE_LINE_NUMBER (next) != NOTE_INSN_FUNCTION_END)
|
next = NEXT_INSN (next);
|
next = NEXT_INSN (next);
|
/* Keep going past other deleted labels to delete what follows. */
|
/* Keep going past other deleted labels to delete what follows. */
|
else if (code == CODE_LABEL && INSN_DELETED_P (next))
|
else if (code == CODE_LABEL && INSN_DELETED_P (next))
|
next = NEXT_INSN (next);
|
next = NEXT_INSN (next);
|
else if (code == BARRIER || INSN_P (next))
|
else if (code == BARRIER || INSN_P (next))
|
/* Note: if this deletes a jump, it can cause more
|
/* Note: if this deletes a jump, it can cause more
|
deletion of unreachable code, after a different label.
|
deletion of unreachable code, after a different label.
|
As long as the value from this recursive call is correct,
|
As long as the value from this recursive call is correct,
|
this invocation functions correctly. */
|
this invocation functions correctly. */
|
next = delete_related_insns (next);
|
next = delete_related_insns (next);
|
else
|
else
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
return next;
|
return next;
|
}
|
}
|
|
|
/* Delete a range of insns from FROM to TO, inclusive.
|
/* Delete a range of insns from FROM to TO, inclusive.
|
This is for the sake of peephole optimization, so assume
|
This is for the sake of peephole optimization, so assume
|
that whatever these insns do will still be done by a new
|
that whatever these insns do will still be done by a new
|
peephole insn that will replace them. */
|
peephole insn that will replace them. */
|
|
|
void
|
void
|
delete_for_peephole (rtx from, rtx to)
|
delete_for_peephole (rtx from, rtx to)
|
{
|
{
|
rtx insn = from;
|
rtx insn = from;
|
|
|
while (1)
|
while (1)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
rtx prev = PREV_INSN (insn);
|
rtx prev = PREV_INSN (insn);
|
|
|
if (!NOTE_P (insn))
|
if (!NOTE_P (insn))
|
{
|
{
|
INSN_DELETED_P (insn) = 1;
|
INSN_DELETED_P (insn) = 1;
|
|
|
/* Patch this insn out of the chain. */
|
/* Patch this insn out of the chain. */
|
/* We don't do this all at once, because we
|
/* We don't do this all at once, because we
|
must preserve all NOTEs. */
|
must preserve all NOTEs. */
|
if (prev)
|
if (prev)
|
NEXT_INSN (prev) = next;
|
NEXT_INSN (prev) = next;
|
|
|
if (next)
|
if (next)
|
PREV_INSN (next) = prev;
|
PREV_INSN (next) = prev;
|
}
|
}
|
|
|
if (insn == to)
|
if (insn == to)
|
break;
|
break;
|
insn = next;
|
insn = next;
|
}
|
}
|
|
|
/* Note that if TO is an unconditional jump
|
/* Note that if TO is an unconditional jump
|
we *do not* delete the BARRIER that follows,
|
we *do not* delete the BARRIER that follows,
|
since the peephole that replaces this sequence
|
since the peephole that replaces this sequence
|
is also an unconditional jump in that case. */
|
is also an unconditional jump in that case. */
|
}
|
}
|
|
|
/* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
|
/* Throughout LOC, redirect OLABEL to NLABEL. Treat null OLABEL or
|
NLABEL as a return. Accrue modifications into the change group. */
|
NLABEL as a return. Accrue modifications into the change group. */
|
|
|
static void
|
static void
|
redirect_exp_1 (rtx *loc, rtx olabel, rtx nlabel, rtx insn)
|
redirect_exp_1 (rtx *loc, rtx olabel, rtx nlabel, rtx insn)
|
{
|
{
|
rtx x = *loc;
|
rtx x = *loc;
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
int i;
|
int i;
|
const char *fmt;
|
const char *fmt;
|
|
|
if (code == LABEL_REF)
|
if (code == LABEL_REF)
|
{
|
{
|
if (XEXP (x, 0) == olabel)
|
if (XEXP (x, 0) == olabel)
|
{
|
{
|
rtx n;
|
rtx n;
|
if (nlabel)
|
if (nlabel)
|
n = gen_rtx_LABEL_REF (Pmode, nlabel);
|
n = gen_rtx_LABEL_REF (Pmode, nlabel);
|
else
|
else
|
n = gen_rtx_RETURN (VOIDmode);
|
n = gen_rtx_RETURN (VOIDmode);
|
|
|
validate_change (insn, loc, n, 1);
|
validate_change (insn, loc, n, 1);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else if (code == RETURN && olabel == 0)
|
else if (code == RETURN && olabel == 0)
|
{
|
{
|
if (nlabel)
|
if (nlabel)
|
x = gen_rtx_LABEL_REF (Pmode, nlabel);
|
x = gen_rtx_LABEL_REF (Pmode, nlabel);
|
else
|
else
|
x = gen_rtx_RETURN (VOIDmode);
|
x = gen_rtx_RETURN (VOIDmode);
|
if (loc == &PATTERN (insn))
|
if (loc == &PATTERN (insn))
|
x = gen_rtx_SET (VOIDmode, pc_rtx, x);
|
x = gen_rtx_SET (VOIDmode, pc_rtx, x);
|
validate_change (insn, loc, x, 1);
|
validate_change (insn, loc, x, 1);
|
return;
|
return;
|
}
|
}
|
|
|
if (code == SET && nlabel == 0 && SET_DEST (x) == pc_rtx
|
if (code == SET && nlabel == 0 && SET_DEST (x) == pc_rtx
|
&& GET_CODE (SET_SRC (x)) == LABEL_REF
|
&& GET_CODE (SET_SRC (x)) == LABEL_REF
|
&& XEXP (SET_SRC (x), 0) == olabel)
|
&& XEXP (SET_SRC (x), 0) == olabel)
|
{
|
{
|
validate_change (insn, loc, gen_rtx_RETURN (VOIDmode), 1);
|
validate_change (insn, loc, gen_rtx_RETURN (VOIDmode), 1);
|
return;
|
return;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
redirect_exp_1 (&XEXP (x, i), olabel, nlabel, insn);
|
redirect_exp_1 (&XEXP (x, i), olabel, nlabel, insn);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
redirect_exp_1 (&XVECEXP (x, i, j), olabel, nlabel, insn);
|
redirect_exp_1 (&XVECEXP (x, i, j), olabel, nlabel, insn);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Make JUMP go to NLABEL instead of where it jumps now. Accrue
|
/* Make JUMP go to NLABEL instead of where it jumps now. Accrue
|
the modifications into the change group. Return false if we did
|
the modifications into the change group. Return false if we did
|
not see how to do that. */
|
not see how to do that. */
|
|
|
int
|
int
|
redirect_jump_1 (rtx jump, rtx nlabel)
|
redirect_jump_1 (rtx jump, rtx nlabel)
|
{
|
{
|
int ochanges = num_validated_changes ();
|
int ochanges = num_validated_changes ();
|
rtx *loc;
|
rtx *loc;
|
|
|
if (GET_CODE (PATTERN (jump)) == PARALLEL)
|
if (GET_CODE (PATTERN (jump)) == PARALLEL)
|
loc = &XVECEXP (PATTERN (jump), 0, 0);
|
loc = &XVECEXP (PATTERN (jump), 0, 0);
|
else
|
else
|
loc = &PATTERN (jump);
|
loc = &PATTERN (jump);
|
|
|
redirect_exp_1 (loc, JUMP_LABEL (jump), nlabel, jump);
|
redirect_exp_1 (loc, JUMP_LABEL (jump), nlabel, jump);
|
return num_validated_changes () > ochanges;
|
return num_validated_changes () > ochanges;
|
}
|
}
|
|
|
/* Make JUMP go to NLABEL instead of where it jumps now. If the old
|
/* Make JUMP go to NLABEL instead of where it jumps now. If the old
|
jump target label is unused as a result, it and the code following
|
jump target label is unused as a result, it and the code following
|
it may be deleted.
|
it may be deleted.
|
|
|
If NLABEL is zero, we are to turn the jump into a (possibly conditional)
|
If NLABEL is zero, we are to turn the jump into a (possibly conditional)
|
RETURN insn.
|
RETURN insn.
|
|
|
The return value will be 1 if the change was made, 0 if it wasn't
|
The return value will be 1 if the change was made, 0 if it wasn't
|
(this can only occur for NLABEL == 0). */
|
(this can only occur for NLABEL == 0). */
|
|
|
int
|
int
|
redirect_jump (rtx jump, rtx nlabel, int delete_unused)
|
redirect_jump (rtx jump, rtx nlabel, int delete_unused)
|
{
|
{
|
rtx olabel = JUMP_LABEL (jump);
|
rtx olabel = JUMP_LABEL (jump);
|
|
|
if (nlabel == olabel)
|
if (nlabel == olabel)
|
return 1;
|
return 1;
|
|
|
if (! redirect_jump_1 (jump, nlabel) || ! apply_change_group ())
|
if (! redirect_jump_1 (jump, nlabel) || ! apply_change_group ())
|
return 0;
|
return 0;
|
|
|
redirect_jump_2 (jump, olabel, nlabel, delete_unused, 0);
|
redirect_jump_2 (jump, olabel, nlabel, delete_unused, 0);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Fix up JUMP_LABEL and label ref counts after OLABEL has been replaced with
|
/* Fix up JUMP_LABEL and label ref counts after OLABEL has been replaced with
|
NLABEL in JUMP. If DELETE_UNUSED is non-negative, copy a
|
NLABEL in JUMP. If DELETE_UNUSED is non-negative, copy a
|
NOTE_INSN_FUNCTION_END found after OLABEL to the place after NLABEL.
|
NOTE_INSN_FUNCTION_END found after OLABEL to the place after NLABEL.
|
If DELETE_UNUSED is positive, delete related insn to OLABEL if its ref
|
If DELETE_UNUSED is positive, delete related insn to OLABEL if its ref
|
count has dropped to zero. */
|
count has dropped to zero. */
|
void
|
void
|
redirect_jump_2 (rtx jump, rtx olabel, rtx nlabel, int delete_unused,
|
redirect_jump_2 (rtx jump, rtx olabel, rtx nlabel, int delete_unused,
|
int invert)
|
int invert)
|
{
|
{
|
rtx note;
|
rtx note;
|
|
|
JUMP_LABEL (jump) = nlabel;
|
JUMP_LABEL (jump) = nlabel;
|
if (nlabel)
|
if (nlabel)
|
++LABEL_NUSES (nlabel);
|
++LABEL_NUSES (nlabel);
|
|
|
/* Update labels in any REG_EQUAL note. */
|
/* Update labels in any REG_EQUAL note. */
|
if ((note = find_reg_note (jump, REG_EQUAL, NULL_RTX)) != NULL_RTX)
|
if ((note = find_reg_note (jump, REG_EQUAL, NULL_RTX)) != NULL_RTX)
|
{
|
{
|
if (!nlabel || (invert && !invert_exp_1 (XEXP (note, 0), jump)))
|
if (!nlabel || (invert && !invert_exp_1 (XEXP (note, 0), jump)))
|
remove_note (jump, note);
|
remove_note (jump, note);
|
else
|
else
|
{
|
{
|
redirect_exp_1 (&XEXP (note, 0), olabel, nlabel, jump);
|
redirect_exp_1 (&XEXP (note, 0), olabel, nlabel, jump);
|
confirm_change_group ();
|
confirm_change_group ();
|
}
|
}
|
}
|
}
|
|
|
/* If we're eliding the jump over exception cleanups at the end of a
|
/* If we're eliding the jump over exception cleanups at the end of a
|
function, move the function end note so that -Wreturn-type works. */
|
function, move the function end note so that -Wreturn-type works. */
|
if (olabel && nlabel
|
if (olabel && nlabel
|
&& NEXT_INSN (olabel)
|
&& NEXT_INSN (olabel)
|
&& NOTE_P (NEXT_INSN (olabel))
|
&& NOTE_P (NEXT_INSN (olabel))
|
&& NOTE_LINE_NUMBER (NEXT_INSN (olabel)) == NOTE_INSN_FUNCTION_END
|
&& NOTE_LINE_NUMBER (NEXT_INSN (olabel)) == NOTE_INSN_FUNCTION_END
|
&& delete_unused >= 0)
|
&& delete_unused >= 0)
|
emit_note_after (NOTE_INSN_FUNCTION_END, nlabel);
|
emit_note_after (NOTE_INSN_FUNCTION_END, nlabel);
|
|
|
if (olabel && --LABEL_NUSES (olabel) == 0 && delete_unused > 0
|
if (olabel && --LABEL_NUSES (olabel) == 0 && delete_unused > 0
|
/* Undefined labels will remain outside the insn stream. */
|
/* Undefined labels will remain outside the insn stream. */
|
&& INSN_UID (olabel))
|
&& INSN_UID (olabel))
|
delete_related_insns (olabel);
|
delete_related_insns (olabel);
|
if (invert)
|
if (invert)
|
invert_br_probabilities (jump);
|
invert_br_probabilities (jump);
|
}
|
}
|
|
|
/* Invert the jump condition X contained in jump insn INSN. Accrue the
|
/* Invert the jump condition X contained in jump insn INSN. Accrue the
|
modifications into the change group. Return nonzero for success. */
|
modifications into the change group. Return nonzero for success. */
|
static int
|
static int
|
invert_exp_1 (rtx x, rtx insn)
|
invert_exp_1 (rtx x, rtx insn)
|
{
|
{
|
RTX_CODE code = GET_CODE (x);
|
RTX_CODE code = GET_CODE (x);
|
|
|
if (code == IF_THEN_ELSE)
|
if (code == IF_THEN_ELSE)
|
{
|
{
|
rtx comp = XEXP (x, 0);
|
rtx comp = XEXP (x, 0);
|
rtx tem;
|
rtx tem;
|
enum rtx_code reversed_code;
|
enum rtx_code reversed_code;
|
|
|
/* We can do this in two ways: The preferable way, which can only
|
/* We can do this in two ways: The preferable way, which can only
|
be done if this is not an integer comparison, is to reverse
|
be done if this is not an integer comparison, is to reverse
|
the comparison code. Otherwise, swap the THEN-part and ELSE-part
|
the comparison code. Otherwise, swap the THEN-part and ELSE-part
|
of the IF_THEN_ELSE. If we can't do either, fail. */
|
of the IF_THEN_ELSE. If we can't do either, fail. */
|
|
|
reversed_code = reversed_comparison_code (comp, insn);
|
reversed_code = reversed_comparison_code (comp, insn);
|
|
|
if (reversed_code != UNKNOWN)
|
if (reversed_code != UNKNOWN)
|
{
|
{
|
validate_change (insn, &XEXP (x, 0),
|
validate_change (insn, &XEXP (x, 0),
|
gen_rtx_fmt_ee (reversed_code,
|
gen_rtx_fmt_ee (reversed_code,
|
GET_MODE (comp), XEXP (comp, 0),
|
GET_MODE (comp), XEXP (comp, 0),
|
XEXP (comp, 1)),
|
XEXP (comp, 1)),
|
1);
|
1);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
tem = XEXP (x, 1);
|
tem = XEXP (x, 1);
|
validate_change (insn, &XEXP (x, 1), XEXP (x, 2), 1);
|
validate_change (insn, &XEXP (x, 1), XEXP (x, 2), 1);
|
validate_change (insn, &XEXP (x, 2), tem, 1);
|
validate_change (insn, &XEXP (x, 2), tem, 1);
|
return 1;
|
return 1;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Invert the condition of the jump JUMP, and make it jump to label
|
/* Invert the condition of the jump JUMP, and make it jump to label
|
NLABEL instead of where it jumps now. Accrue changes into the
|
NLABEL instead of where it jumps now. Accrue changes into the
|
change group. Return false if we didn't see how to perform the
|
change group. Return false if we didn't see how to perform the
|
inversion and redirection. */
|
inversion and redirection. */
|
|
|
int
|
int
|
invert_jump_1 (rtx jump, rtx nlabel)
|
invert_jump_1 (rtx jump, rtx nlabel)
|
{
|
{
|
rtx x = pc_set (jump);
|
rtx x = pc_set (jump);
|
int ochanges;
|
int ochanges;
|
int ok;
|
int ok;
|
|
|
ochanges = num_validated_changes ();
|
ochanges = num_validated_changes ();
|
gcc_assert (x);
|
gcc_assert (x);
|
ok = invert_exp_1 (SET_SRC (x), jump);
|
ok = invert_exp_1 (SET_SRC (x), jump);
|
gcc_assert (ok);
|
gcc_assert (ok);
|
|
|
if (num_validated_changes () == ochanges)
|
if (num_validated_changes () == ochanges)
|
return 0;
|
return 0;
|
|
|
/* redirect_jump_1 will fail of nlabel == olabel, and the current use is
|
/* redirect_jump_1 will fail of nlabel == olabel, and the current use is
|
in Pmode, so checking this is not merely an optimization. */
|
in Pmode, so checking this is not merely an optimization. */
|
return nlabel == JUMP_LABEL (jump) || redirect_jump_1 (jump, nlabel);
|
return nlabel == JUMP_LABEL (jump) || redirect_jump_1 (jump, nlabel);
|
}
|
}
|
|
|
/* Invert the condition of the jump JUMP, and make it jump to label
|
/* Invert the condition of the jump JUMP, and make it jump to label
|
NLABEL instead of where it jumps now. Return true if successful. */
|
NLABEL instead of where it jumps now. Return true if successful. */
|
|
|
int
|
int
|
invert_jump (rtx jump, rtx nlabel, int delete_unused)
|
invert_jump (rtx jump, rtx nlabel, int delete_unused)
|
{
|
{
|
rtx olabel = JUMP_LABEL (jump);
|
rtx olabel = JUMP_LABEL (jump);
|
|
|
if (invert_jump_1 (jump, nlabel) && apply_change_group ())
|
if (invert_jump_1 (jump, nlabel) && apply_change_group ())
|
{
|
{
|
redirect_jump_2 (jump, olabel, nlabel, delete_unused, 1);
|
redirect_jump_2 (jump, olabel, nlabel, delete_unused, 1);
|
return 1;
|
return 1;
|
}
|
}
|
cancel_changes (0);
|
cancel_changes (0);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
/* Like rtx_equal_p except that it considers two REGs as equal
|
/* Like rtx_equal_p except that it considers two REGs as equal
|
if they renumber to the same value and considers two commutative
|
if they renumber to the same value and considers two commutative
|
operations to be the same if the order of the operands has been
|
operations to be the same if the order of the operands has been
|
reversed. */
|
reversed. */
|
|
|
int
|
int
|
rtx_renumbered_equal_p (rtx x, rtx y)
|
rtx_renumbered_equal_p (rtx x, rtx y)
|
{
|
{
|
int i;
|
int i;
|
enum rtx_code code = GET_CODE (x);
|
enum rtx_code code = GET_CODE (x);
|
const char *fmt;
|
const char *fmt;
|
|
|
if (x == y)
|
if (x == y)
|
return 1;
|
return 1;
|
|
|
if ((code == REG || (code == SUBREG && REG_P (SUBREG_REG (x))))
|
if ((code == REG || (code == SUBREG && REG_P (SUBREG_REG (x))))
|
&& (REG_P (y) || (GET_CODE (y) == SUBREG
|
&& (REG_P (y) || (GET_CODE (y) == SUBREG
|
&& REG_P (SUBREG_REG (y)))))
|
&& REG_P (SUBREG_REG (y)))))
|
{
|
{
|
int reg_x = -1, reg_y = -1;
|
int reg_x = -1, reg_y = -1;
|
int byte_x = 0, byte_y = 0;
|
int byte_x = 0, byte_y = 0;
|
|
|
if (GET_MODE (x) != GET_MODE (y))
|
if (GET_MODE (x) != GET_MODE (y))
|
return 0;
|
return 0;
|
|
|
/* If we haven't done any renumbering, don't
|
/* If we haven't done any renumbering, don't
|
make any assumptions. */
|
make any assumptions. */
|
if (reg_renumber == 0)
|
if (reg_renumber == 0)
|
return rtx_equal_p (x, y);
|
return rtx_equal_p (x, y);
|
|
|
if (code == SUBREG)
|
if (code == SUBREG)
|
{
|
{
|
reg_x = REGNO (SUBREG_REG (x));
|
reg_x = REGNO (SUBREG_REG (x));
|
byte_x = SUBREG_BYTE (x);
|
byte_x = SUBREG_BYTE (x);
|
|
|
if (reg_renumber[reg_x] >= 0)
|
if (reg_renumber[reg_x] >= 0)
|
{
|
{
|
reg_x = subreg_regno_offset (reg_renumber[reg_x],
|
reg_x = subreg_regno_offset (reg_renumber[reg_x],
|
GET_MODE (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
byte_x,
|
byte_x,
|
GET_MODE (x));
|
GET_MODE (x));
|
byte_x = 0;
|
byte_x = 0;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
reg_x = REGNO (x);
|
reg_x = REGNO (x);
|
if (reg_renumber[reg_x] >= 0)
|
if (reg_renumber[reg_x] >= 0)
|
reg_x = reg_renumber[reg_x];
|
reg_x = reg_renumber[reg_x];
|
}
|
}
|
|
|
if (GET_CODE (y) == SUBREG)
|
if (GET_CODE (y) == SUBREG)
|
{
|
{
|
reg_y = REGNO (SUBREG_REG (y));
|
reg_y = REGNO (SUBREG_REG (y));
|
byte_y = SUBREG_BYTE (y);
|
byte_y = SUBREG_BYTE (y);
|
|
|
if (reg_renumber[reg_y] >= 0)
|
if (reg_renumber[reg_y] >= 0)
|
{
|
{
|
reg_y = subreg_regno_offset (reg_renumber[reg_y],
|
reg_y = subreg_regno_offset (reg_renumber[reg_y],
|
GET_MODE (SUBREG_REG (y)),
|
GET_MODE (SUBREG_REG (y)),
|
byte_y,
|
byte_y,
|
GET_MODE (y));
|
GET_MODE (y));
|
byte_y = 0;
|
byte_y = 0;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
reg_y = REGNO (y);
|
reg_y = REGNO (y);
|
if (reg_renumber[reg_y] >= 0)
|
if (reg_renumber[reg_y] >= 0)
|
reg_y = reg_renumber[reg_y];
|
reg_y = reg_renumber[reg_y];
|
}
|
}
|
|
|
return reg_x >= 0 && reg_x == reg_y && byte_x == byte_y;
|
return reg_x >= 0 && reg_x == reg_y && byte_x == byte_y;
|
}
|
}
|
|
|
/* Now we have disposed of all the cases
|
/* Now we have disposed of all the cases
|
in which different rtx codes can match. */
|
in which different rtx codes can match. */
|
if (code != GET_CODE (y))
|
if (code != GET_CODE (y))
|
return 0;
|
return 0;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
case ADDR_VEC:
|
case ADDR_VEC:
|
case ADDR_DIFF_VEC:
|
case ADDR_DIFF_VEC:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
return 0;
|
return 0;
|
|
|
case LABEL_REF:
|
case LABEL_REF:
|
/* We can't assume nonlocal labels have their following insns yet. */
|
/* We can't assume nonlocal labels have their following insns yet. */
|
if (LABEL_REF_NONLOCAL_P (x) || LABEL_REF_NONLOCAL_P (y))
|
if (LABEL_REF_NONLOCAL_P (x) || LABEL_REF_NONLOCAL_P (y))
|
return XEXP (x, 0) == XEXP (y, 0);
|
return XEXP (x, 0) == XEXP (y, 0);
|
|
|
/* Two label-refs are equivalent if they point at labels
|
/* Two label-refs are equivalent if they point at labels
|
in the same position in the instruction stream. */
|
in the same position in the instruction stream. */
|
return (next_real_insn (XEXP (x, 0))
|
return (next_real_insn (XEXP (x, 0))
|
== next_real_insn (XEXP (y, 0)));
|
== next_real_insn (XEXP (y, 0)));
|
|
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
return XSTR (x, 0) == XSTR (y, 0);
|
return XSTR (x, 0) == XSTR (y, 0);
|
|
|
case CODE_LABEL:
|
case CODE_LABEL:
|
/* If we didn't match EQ equality above, they aren't the same. */
|
/* If we didn't match EQ equality above, they aren't the same. */
|
return 0;
|
return 0;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
|
/* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
|
|
|
if (GET_MODE (x) != GET_MODE (y))
|
if (GET_MODE (x) != GET_MODE (y))
|
return 0;
|
return 0;
|
|
|
/* For commutative operations, the RTX match if the operand match in any
|
/* For commutative operations, the RTX match if the operand match in any
|
order. Also handle the simple binary and unary cases without a loop. */
|
order. Also handle the simple binary and unary cases without a loop. */
|
if (targetm.commutative_p (x, UNKNOWN))
|
if (targetm.commutative_p (x, UNKNOWN))
|
return ((rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0))
|
return ((rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0))
|
&& rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 1)))
|
&& rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 1)))
|
|| (rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 1))
|
|| (rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 1))
|
&& rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 0))));
|
&& rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 0))));
|
else if (NON_COMMUTATIVE_P (x))
|
else if (NON_COMMUTATIVE_P (x))
|
return (rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0))
|
return (rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0))
|
&& rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 1)));
|
&& rtx_renumbered_equal_p (XEXP (x, 1), XEXP (y, 1)));
|
else if (UNARY_P (x))
|
else if (UNARY_P (x))
|
return rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0));
|
return rtx_renumbered_equal_p (XEXP (x, 0), XEXP (y, 0));
|
|
|
/* Compare the elements. If any pair of corresponding elements
|
/* Compare the elements. If any pair of corresponding elements
|
fail to match, return 0 for the whole things. */
|
fail to match, return 0 for the whole things. */
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
int j;
|
int j;
|
switch (fmt[i])
|
switch (fmt[i])
|
{
|
{
|
case 'w':
|
case 'w':
|
if (XWINT (x, i) != XWINT (y, i))
|
if (XWINT (x, i) != XWINT (y, i))
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case 'i':
|
case 'i':
|
if (XINT (x, i) != XINT (y, i))
|
if (XINT (x, i) != XINT (y, i))
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case 't':
|
case 't':
|
if (XTREE (x, i) != XTREE (y, i))
|
if (XTREE (x, i) != XTREE (y, i))
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case 's':
|
case 's':
|
if (strcmp (XSTR (x, i), XSTR (y, i)))
|
if (strcmp (XSTR (x, i), XSTR (y, i)))
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case 'e':
|
case 'e':
|
if (! rtx_renumbered_equal_p (XEXP (x, i), XEXP (y, i)))
|
if (! rtx_renumbered_equal_p (XEXP (x, i), XEXP (y, i)))
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
case 'u':
|
case 'u':
|
if (XEXP (x, i) != XEXP (y, i))
|
if (XEXP (x, i) != XEXP (y, i))
|
return 0;
|
return 0;
|
/* Fall through. */
|
/* Fall through. */
|
case '0':
|
case '0':
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
if (XVECLEN (x, i) != XVECLEN (y, i))
|
if (XVECLEN (x, i) != XVECLEN (y, i))
|
return 0;
|
return 0;
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
if (!rtx_renumbered_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)))
|
if (!rtx_renumbered_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)))
|
return 0;
|
return 0;
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* If X is a hard register or equivalent to one or a subregister of one,
|
/* If X is a hard register or equivalent to one or a subregister of one,
|
return the hard register number. If X is a pseudo register that was not
|
return the hard register number. If X is a pseudo register that was not
|
assigned a hard register, return the pseudo register number. Otherwise,
|
assigned a hard register, return the pseudo register number. Otherwise,
|
return -1. Any rtx is valid for X. */
|
return -1. Any rtx is valid for X. */
|
|
|
int
|
int
|
true_regnum (rtx x)
|
true_regnum (rtx x)
|
{
|
{
|
if (REG_P (x))
|
if (REG_P (x))
|
{
|
{
|
if (REGNO (x) >= FIRST_PSEUDO_REGISTER && reg_renumber[REGNO (x)] >= 0)
|
if (REGNO (x) >= FIRST_PSEUDO_REGISTER && reg_renumber[REGNO (x)] >= 0)
|
return reg_renumber[REGNO (x)];
|
return reg_renumber[REGNO (x)];
|
return REGNO (x);
|
return REGNO (x);
|
}
|
}
|
if (GET_CODE (x) == SUBREG)
|
if (GET_CODE (x) == SUBREG)
|
{
|
{
|
int base = true_regnum (SUBREG_REG (x));
|
int base = true_regnum (SUBREG_REG (x));
|
if (base >= 0
|
if (base >= 0
|
&& base < FIRST_PSEUDO_REGISTER
|
&& base < FIRST_PSEUDO_REGISTER
|
&& subreg_offset_representable_p (REGNO (SUBREG_REG (x)),
|
&& subreg_offset_representable_p (REGNO (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
SUBREG_BYTE (x), GET_MODE (x)))
|
SUBREG_BYTE (x), GET_MODE (x)))
|
return base + subreg_regno_offset (REGNO (SUBREG_REG (x)),
|
return base + subreg_regno_offset (REGNO (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
SUBREG_BYTE (x), GET_MODE (x));
|
SUBREG_BYTE (x), GET_MODE (x));
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
/* Return regno of the register REG and handle subregs too. */
|
/* Return regno of the register REG and handle subregs too. */
|
unsigned int
|
unsigned int
|
reg_or_subregno (rtx reg)
|
reg_or_subregno (rtx reg)
|
{
|
{
|
if (GET_CODE (reg) == SUBREG)
|
if (GET_CODE (reg) == SUBREG)
|
reg = SUBREG_REG (reg);
|
reg = SUBREG_REG (reg);
|
gcc_assert (REG_P (reg));
|
gcc_assert (REG_P (reg));
|
return REGNO (reg);
|
return REGNO (reg);
|
}
|
}
|
|
|
