/* 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, 2008, 2009
|
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
|
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 mark_jump_label_1 (rtx, rtx, bool, bool);
|
static void mark_jump_label_1 (rtx, rtx, bool, bool);
|
static void mark_jump_label_asm (rtx, rtx);
|
static void mark_jump_label_asm (rtx, 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 *);
|
|
|
/* This function rebuilds the JUMP_LABEL field and REG_LABEL_TARGET
|
/* This function rebuilds the JUMP_LABEL field and REG_LABEL_TARGET
|
notes in jumping insns and REG_LABEL_OPERAND notes in non-jumping
|
notes in jumping insns and REG_LABEL_OPERAND notes in non-jumping
|
instructions and jumping insns that have labels as operands
|
instructions and jumping insns that have labels as operands
|
(e.g. cbranchsi4). */
|
(e.g. cbranchsi4). */
|
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 (!prev)
|
if (!prev)
|
continue;
|
continue;
|
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 rtl_opt_pass pass_cleanup_barriers =
|
struct rtl_opt_pass pass_cleanup_barriers =
|
{
|
{
|
{
|
{
|
RTL_PASS,
|
RTL_PASS,
|
"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 */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* 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 */
|
}
|
}
|
};
|
};
|
|
|
|
|
/* Initialize LABEL_NUSES and JUMP_LABEL fields, add REG_LABEL_TARGET
|
/* Initialize LABEL_NUSES and JUMP_LABEL fields, add REG_LABEL_TARGET
|
for remaining targets for JUMP_P. Delete any REG_LABEL_OPERAND
|
for remaining targets for JUMP_P. Delete any REG_LABEL_OPERAND
|
notes whose labels don't occur in the insn any more. */
|
notes whose labels don't occur in the insn any more. */
|
|
|
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);
|
|
|
/* REG_LABEL_TARGET notes (including the JUMP_LABEL field) are
|
/* REG_LABEL_TARGET notes (including the JUMP_LABEL field) are
|
sticky and not reset here; that way we won't lose association
|
sticky and not reset here; that way we won't lose association
|
with a label when e.g. the source for a target register
|
with a label when e.g. the source for a target register
|
disappears out of reach for targets that may use jump-target
|
disappears out of reach for targets that may use jump-target
|
registers. Jump transformations are supposed to transform
|
registers. Jump transformations are supposed to transform
|
any REG_LABEL_TARGET notes. The target label reference in a
|
any REG_LABEL_TARGET notes. The target label reference in a
|
branch may disappear from the branch (and from the
|
branch may disappear from the branch (and from the
|
instruction before it) for other reasons, like register
|
instruction before it) for other reasons, like register
|
allocation. */
|
allocation. */
|
|
|
if (INSN_P (insn))
|
if (INSN_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_OPERAND
|
if (REG_NOTE_KIND (note) == REG_LABEL_OPERAND
|
&& ! 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;
|
rtx prev_nonjump_insn = NULL;
|
rtx prev_nonjump_insn = NULL;
|
|
|
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 the previous non-jump insn sets something to a label,
|
/* If the previous non-jump insn sets something to a label,
|
something that this jump insn uses, make that label the primary
|
something that this jump insn uses, make that label the primary
|
target of this insn if we don't yet have any. That previous
|
target of this insn if we don't yet have any. That previous
|
insn must be a single_set and not refer to more than one label.
|
insn must be a single_set and not refer to more than one label.
|
The jump insn must not refer to other labels as jump targets
|
The jump insn must not refer to other labels as jump targets
|
and must be a plain (set (pc) ...), maybe in a parallel, and
|
and must be a plain (set (pc) ...), maybe in a parallel, and
|
may refer to the item being set only directly or as one of the
|
may refer to the item being set only directly or as one of the
|
arms in an IF_THEN_ELSE. */
|
arms in an IF_THEN_ELSE. */
|
if (! INSN_DELETED_P (insn)
|
if (! INSN_DELETED_P (insn)
|
&& JUMP_P (insn)
|
&& JUMP_P (insn)
|
&& JUMP_LABEL (insn) == NULL)
|
&& JUMP_LABEL (insn) == NULL)
|
{
|
{
|
rtx label_note = NULL;
|
rtx label_note = NULL;
|
rtx pc = pc_set (insn);
|
rtx pc = pc_set (insn);
|
rtx pc_src = pc != NULL ? SET_SRC (pc) : NULL;
|
rtx pc_src = pc != NULL ? SET_SRC (pc) : NULL;
|
|
|
if (prev_nonjump_insn != NULL)
|
if (prev_nonjump_insn != NULL)
|
label_note
|
label_note
|
= find_reg_note (prev_nonjump_insn, REG_LABEL_OPERAND, NULL);
|
= find_reg_note (prev_nonjump_insn, REG_LABEL_OPERAND, NULL);
|
|
|
if (label_note != NULL && pc_src != NULL)
|
if (label_note != NULL && pc_src != NULL)
|
{
|
{
|
rtx label_set = single_set (prev_nonjump_insn);
|
rtx label_set = single_set (prev_nonjump_insn);
|
rtx label_dest
|
rtx label_dest
|
= label_set != NULL ? SET_DEST (label_set) : NULL;
|
= label_set != NULL ? SET_DEST (label_set) : NULL;
|
|
|
if (label_set != NULL
|
if (label_set != NULL
|
/* The source must be the direct LABEL_REF, not a
|
/* The source must be the direct LABEL_REF, not a
|
PLUS, UNSPEC, IF_THEN_ELSE etc. */
|
PLUS, UNSPEC, IF_THEN_ELSE etc. */
|
&& GET_CODE (SET_SRC (label_set)) == LABEL_REF
|
&& GET_CODE (SET_SRC (label_set)) == LABEL_REF
|
&& (rtx_equal_p (label_dest, pc_src)
|
&& (rtx_equal_p (label_dest, pc_src)
|
|| (GET_CODE (pc_src) == IF_THEN_ELSE
|
|| (GET_CODE (pc_src) == IF_THEN_ELSE
|
&& (rtx_equal_p (label_dest, XEXP (pc_src, 1))
|
&& (rtx_equal_p (label_dest, XEXP (pc_src, 1))
|
|| rtx_equal_p (label_dest,
|
|| rtx_equal_p (label_dest,
|
XEXP (pc_src, 2))))))
|
XEXP (pc_src, 2))))))
|
|
|
{
|
{
|
/* The CODE_LABEL referred to in the note must be the
|
/* The CODE_LABEL referred to in the note must be the
|
CODE_LABEL in the LABEL_REF of the "set". We can
|
CODE_LABEL in the LABEL_REF of the "set". We can
|
conveniently use it for the marker function, which
|
conveniently use it for the marker function, which
|
requires a LABEL_REF wrapping. */
|
requires a LABEL_REF wrapping. */
|
gcc_assert (XEXP (label_note, 0)
|
gcc_assert (XEXP (label_note, 0)
|
== XEXP (SET_SRC (label_set), 0));
|
== XEXP (SET_SRC (label_set), 0));
|
|
|
mark_jump_label_1 (label_set, insn, false, true);
|
mark_jump_label_1 (label_set, insn, false, true);
|
gcc_assert (JUMP_LABEL (insn)
|
gcc_assert (JUMP_LABEL (insn)
|
== XEXP (SET_SRC (label_set), 0));
|
== XEXP (SET_SRC (label_set), 0));
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (! INSN_DELETED_P (insn))
|
else if (! INSN_DELETED_P (insn))
|
prev_nonjump_insn = insn;
|
prev_nonjump_insn = insn;
|
}
|
}
|
else if (LABEL_P (insn))
|
else if (LABEL_P (insn))
|
prev_nonjump_insn = NULL;
|
prev_nonjump_insn = NULL;
|
|
|
/* If we are in cfglayout mode, there may be non-insns between the
|
/* If we are in cfglayout mode, there may be non-insns between the
|
basic blocks. If those non-insns represent tablejump data, they
|
basic blocks. If those non-insns represent tablejump data, they
|
contain label references that we must record. */
|
contain label references that we must record. */
|
if (current_ir_type () == IR_RTL_CFGLAYOUT)
|
if (current_ir_type () == IR_RTL_CFGLAYOUT)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
rtx insn;
|
rtx insn;
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
for (insn = bb->il.rtl->header; insn; insn = NEXT_INSN (insn))
|
for (insn = bb->il.rtl->header; insn; insn = NEXT_INSN (insn))
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
gcc_assert (JUMP_TABLE_DATA_P (insn));
|
gcc_assert (JUMP_TABLE_DATA_P (insn));
|
mark_jump_label (PATTERN (insn), insn, 0);
|
mark_jump_label (PATTERN (insn), insn, 0);
|
}
|
}
|
|
|
for (insn = bb->il.rtl->footer; insn; insn = NEXT_INSN (insn))
|
for (insn = bb->il.rtl->footer; insn; insn = NEXT_INSN (insn))
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
gcc_assert (JUMP_TABLE_DATA_P (insn));
|
gcc_assert (JUMP_TABLE_DATA_P (insn));
|
mark_jump_label (PATTERN (insn), insn, 0);
|
mark_jump_label (PATTERN (insn), insn, 0);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* 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, const_rtx arg0,
|
reversed_comparison_code_parts (enum rtx_code code, const_rtx arg0,
|
const_rtx arg1, const_rtx insn)
|
const_rtx arg1, const_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))
|
{
|
{
|
const_rtx prev;
|
const_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;
|
|
|
/* These CONST_CAST's are okay because prev_nonnote_insn just
|
/* These CONST_CAST's are okay because prev_nonnote_insn just
|
returns its argument and we assign it to a const_rtx
|
returns its argument and we assign it to a const_rtx
|
variable. */
|
variable. */
|
for (prev = prev_nonnote_insn (CONST_CAST_RTX(insn));
|
for (prev = prev_nonnote_insn (CONST_CAST_RTX(insn));
|
prev != 0 && !LABEL_P (prev);
|
prev != 0 && !LABEL_P (prev);
|
prev = prev_nonnote_insn (CONST_CAST_RTX(prev)))
|
prev = prev_nonnote_insn (CONST_CAST_RTX(prev)))
|
{
|
{
|
const_rtx set = set_of (arg0, prev);
|
const_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 (CONST_INT_P (arg0)
|
if (CONST_INT_P (arg0)
|
|| (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 (const_rtx comparison, const_rtx insn)
|
reversed_comparison_code (const_rtx comparison, const_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 (const_rtx exp, enum machine_mode mode)
|
reversed_comparison (const_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 (const_rtx insn)
|
simplejump_p (const_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 (const_rtx insn)
|
condjump_p (const_rtx insn)
|
{
|
{
|
const_rtx x = PATTERN (insn);
|
const_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 (const_rtx insn)
|
condjump_in_parallel_p (const_rtx insn)
|
{
|
{
|
const_rtx x = PATTERN (insn);
|
const_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 (const_rtx insn)
|
pc_set (const_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 (const_rtx insn)
|
any_uncondjump_p (const_rtx insn)
|
{
|
{
|
const_rtx x = pc_set (insn);
|
const_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 (const_rtx insn)
|
any_condjump_p (const_rtx insn)
|
{
|
{
|
const_rtx x = pc_set (insn);
|
const_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 (const_rtx insn)
|
condjump_label (const_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;
|
|
|
if (x == NULL)
|
if (x == NULL)
|
return false;
|
return false;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case RETURN:
|
case RETURN:
|
case EH_RETURN:
|
case EH_RETURN:
|
return true;
|
return true;
|
|
|
case SET:
|
case SET:
|
return SET_IS_RETURN_P (x);
|
return SET_IS_RETURN_P (x);
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Return TRUE if INSN is a return jump. */
|
/* Return TRUE if INSN is a return jump. */
|
|
|
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 (possibly conditional) return insn. */
|
/* Return true if INSN is a (possibly conditional) return insn. */
|
|
|
static int
|
static int
|
eh_returnjump_p_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
|
eh_returnjump_p_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
|
{
|
{
|
return *loc && GET_CODE (*loc) == EH_RETURN;
|
return *loc && GET_CODE (*loc) == EH_RETURN;
|
}
|
}
|
|
|
int
|
int
|
eh_returnjump_p (rtx insn)
|
eh_returnjump_p (rtx insn)
|
{
|
{
|
if (!JUMP_P (insn))
|
if (!JUMP_P (insn))
|
return 0;
|
return 0;
|
return for_each_rtx (&PATTERN (insn), eh_returnjump_p_1, NULL);
|
return for_each_rtx (&PATTERN (insn), eh_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 (const_rtx insn)
|
onlyjump_p (const_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 (const_rtx x)
|
only_sets_cc0_p (const_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 (const_rtx x)
|
sets_cc0_p (const_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
|
|
|
/* Find all CODE_LABELs referred to in X, and increment their use
|
/* 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
|
counts. If INSN is a JUMP_INSN and there is at least one
|
CODE_LABEL referenced in INSN as a jump target, then store the last
|
CODE_LABEL referenced in INSN as a jump target, then store the last
|
one in JUMP_LABEL (INSN). For a tablejump, this must be the label
|
one in JUMP_LABEL (INSN). For a tablejump, this must be the label
|
for the ADDR_VEC. Store any other jump targets as REG_LABEL_TARGET
|
for the ADDR_VEC. Store any other jump targets as REG_LABEL_TARGET
|
notes. If INSN is an INSN or a CALL_INSN or non-target operands of
|
notes. If INSN is an INSN or a CALL_INSN or non-target operands of
|
a JUMP_INSN, and there is at least one CODE_LABEL referenced in
|
a JUMP_INSN, and there is at least one CODE_LABEL referenced in
|
INSN, add a REG_LABEL_OPERAND note containing that label to INSN.
|
INSN, add a REG_LABEL_OPERAND note containing that label to INSN.
|
|
|
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 asmop = extract_asm_operands (x);
|
rtx asmop = extract_asm_operands (x);
|
if (asmop)
|
if (asmop)
|
mark_jump_label_asm (asmop, insn);
|
mark_jump_label_asm (asmop, insn);
|
else
|
else
|
mark_jump_label_1 (x, insn, in_mem != 0,
|
mark_jump_label_1 (x, insn, in_mem != 0,
|
(insn != NULL && x == PATTERN (insn) && JUMP_P (insn)));
|
(insn != NULL && x == PATTERN (insn) && JUMP_P (insn)));
|
}
|
}
|
|
|
/* Worker function for mark_jump_label. IN_MEM is TRUE when X occurs
|
/* Worker function for mark_jump_label. IN_MEM is TRUE when X occurs
|
within a (MEM ...). IS_TARGET is TRUE when X is to be treated as a
|
within a (MEM ...). IS_TARGET is TRUE when X is to be treated as a
|
jump-target; when the JUMP_LABEL field of INSN should be set or a
|
jump-target; when the JUMP_LABEL field of INSN should be set or a
|
REG_LABEL_TARGET note should be added, not a REG_LABEL_OPERAND
|
REG_LABEL_TARGET note should be added, not a REG_LABEL_OPERAND
|
note. */
|
note. */
|
|
|
static void
|
static void
|
mark_jump_label_1 (rtx x, rtx insn, bool in_mem, bool is_target)
|
mark_jump_label_1 (rtx x, rtx insn, bool in_mem, bool is_target)
|
{
|
{
|
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 = true;
|
in_mem = true;
|
break;
|
break;
|
|
|
case SEQUENCE:
|
case SEQUENCE:
|
for (i = 0; i < XVECLEN (x, 0); i++)
|
for (i = 0; i < XVECLEN (x, 0); i++)
|
mark_jump_label (PATTERN (XVECEXP (x, 0, i)),
|
mark_jump_label (PATTERN (XVECEXP (x, 0, i)),
|
XVECEXP (x, 0, i), 0);
|
XVECEXP (x, 0, i), 0);
|
return;
|
return;
|
|
|
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_1 (get_pool_constant (x), insn, in_mem, is_target);
|
mark_jump_label_1 (get_pool_constant (x), insn, in_mem, is_target);
|
break;
|
break;
|
|
|
/* Handle operands in the condition of an if-then-else as for a
|
/* Handle operands in the condition of an if-then-else as for a
|
non-jump insn. */
|
non-jump insn. */
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
if (!is_target)
|
if (!is_target)
|
break;
|
break;
|
mark_jump_label_1 (XEXP (x, 0), insn, in_mem, false);
|
mark_jump_label_1 (XEXP (x, 0), insn, in_mem, false);
|
mark_jump_label_1 (XEXP (x, 1), insn, in_mem, true);
|
mark_jump_label_1 (XEXP (x, 1), insn, in_mem, true);
|
mark_jump_label_1 (XEXP (x, 2), insn, in_mem, true);
|
mark_jump_label_1 (XEXP (x, 2), insn, in_mem, true);
|
return;
|
return;
|
|
|
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_KIND (label) == NOTE_INSN_DELETED_LABEL)
|
&& NOTE_KIND (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 (is_target
|
if (is_target
|
/* Do not change a previous setting of JUMP_LABEL. If the
|
/* Do not change a previous setting of JUMP_LABEL. If the
|
JUMP_LABEL slot is occupied by a different label,
|
JUMP_LABEL slot is occupied by a different label,
|
create a note for this label. */
|
create a note for this label. */
|
&& (JUMP_LABEL (insn) == NULL || JUMP_LABEL (insn) == label))
|
&& (JUMP_LABEL (insn) == NULL || JUMP_LABEL (insn) == label))
|
JUMP_LABEL (insn) = label;
|
JUMP_LABEL (insn) = label;
|
else
|
else
|
{
|
{
|
enum reg_note kind
|
enum reg_note kind
|
= is_target ? REG_LABEL_TARGET : REG_LABEL_OPERAND;
|
= is_target ? REG_LABEL_TARGET : REG_LABEL_OPERAND;
|
|
|
/* Add a REG_LABEL_OPERAND or REG_LABEL_TARGET note
|
/* Add a REG_LABEL_OPERAND or REG_LABEL_TARGET note
|
for LABEL unless there already is one. All uses of
|
for LABEL unless there already is one. All uses of
|
a label, except for the primary target of a jump,
|
a label, except for the primary target of a jump,
|
must have such a note. */
|
must have such a note. */
|
if (! find_reg_note (insn, kind, label))
|
if (! find_reg_note (insn, kind, label))
|
add_reg_note (insn, kind, label);
|
add_reg_note (insn, kind, label);
|
}
|
}
|
}
|
}
|
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_1 (XVECEXP (x, eltnum, i), NULL_RTX, in_mem,
|
mark_jump_label_1 (XVECEXP (x, eltnum, i), NULL_RTX, in_mem,
|
is_target);
|
is_target);
|
}
|
}
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
|
|
/* The primary target of a tablejump is the label of the ADDR_VEC,
|
/* The primary target of a tablejump is the label of the ADDR_VEC,
|
which is canonically mentioned *last* in the insn. To get it
|
which is canonically mentioned *last* in the insn. To get it
|
marked as JUMP_LABEL, we iterate over items in reverse order. */
|
marked as JUMP_LABEL, we iterate over items in reverse order. */
|
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_1 (XEXP (x, i), insn, in_mem, is_target);
|
mark_jump_label_1 (XEXP (x, i), insn, in_mem, is_target);
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
{
|
{
|
int j;
|
int j;
|
|
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
mark_jump_label_1 (XVECEXP (x, i, j), insn, in_mem,
|
mark_jump_label_1 (XVECEXP (x, i, j), insn, in_mem,
|
is_target);
|
is_target);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Worker function for mark_jump_label. Handle asm insns specially.
|
/* Worker function for mark_jump_label. Handle asm insns specially.
|
In particular, output operands need not be considered so we can
|
In particular, output operands need not be considered so we can
|
avoid re-scanning the replicated asm_operand. Also, the asm_labels
|
avoid re-scanning the replicated asm_operand. Also, the asm_labels
|
need to be considered targets. */
|
need to be considered targets. */
|
|
|
static void
|
static void
|
mark_jump_label_asm (rtx asmop, rtx insn)
|
mark_jump_label_asm (rtx asmop, rtx insn)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = ASM_OPERANDS_INPUT_LENGTH (asmop) - 1; i >= 0; --i)
|
for (i = ASM_OPERANDS_INPUT_LENGTH (asmop) - 1; i >= 0; --i)
|
mark_jump_label_1 (ASM_OPERANDS_INPUT (asmop, i), insn, false, false);
|
mark_jump_label_1 (ASM_OPERANDS_INPUT (asmop, i), insn, false, false);
|
|
|
for (i = ASM_OPERANDS_LABEL_LENGTH (asmop) - 1; i >= 0; --i)
|
for (i = ASM_OPERANDS_LABEL_LENGTH (asmop) - 1; i >= 0; --i)
|
mark_jump_label_1 (ASM_OPERANDS_LABEL (asmop, i), insn, false, true);
|
mark_jump_label_1 (ASM_OPERANDS_LABEL (asmop, i), insn, false, true);
|
}
|
}
|
|
|
/* 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);
|
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_TABLE_DATA_P (insn))
|
if (JUMP_TABLE_DATA_P (insn))
|
{
|
{
|
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 any JUMP_P / INSN / CALL_INSN with a
|
/* Likewise for any JUMP_P / INSN / CALL_INSN with a
|
REG_LABEL_OPERAND or REG_LABEL_TARGET note. */
|
REG_LABEL_OPERAND or REG_LABEL_TARGET note. */
|
if (INSN_P (insn))
|
if (INSN_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_OPERAND
|
if ((REG_NOTE_KIND (note) == REG_LABEL_OPERAND
|
|| REG_NOTE_KIND (note) == REG_LABEL_TARGET)
|
|| REG_NOTE_KIND (note) == REG_LABEL_TARGET)
|
/* 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_TABLE_DATA_P (NEXT_INSN (insn)))
|
&& JUMP_TABLE_DATA_P (NEXT_INSN (insn)))
|
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)
|
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;
|
}
|
}
|
}
|
}
|
|
|
/* 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;
|
}
|
}
|
|
|
/* 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;
|
}
|
}
|
|
|
if (code == IF_THEN_ELSE)
|
if (code == IF_THEN_ELSE)
|
{
|
{
|
/* Skip the condition of an IF_THEN_ELSE. We only want to
|
/* Skip the condition of an IF_THEN_ELSE. We only want to
|
change jump destinations, not eventual label comparisons. */
|
change jump destinations, not eventual label comparisons. */
|
redirect_exp_1 (&XEXP (x, 1), olabel, nlabel, insn);
|
redirect_exp_1 (&XEXP (x, 1), olabel, nlabel, insn);
|
redirect_exp_1 (&XEXP (x, 2), olabel, nlabel, insn);
|
redirect_exp_1 (&XEXP (x, 2), olabel, nlabel, insn);
|
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, asmop;
|
rtx *loc, asmop;
|
|
|
asmop = extract_asm_operands (PATTERN (jump));
|
asmop = extract_asm_operands (PATTERN (jump));
|
if (asmop)
|
if (asmop)
|
{
|
{
|
if (nlabel == NULL)
|
if (nlabel == NULL)
|
return 0;
|
return 0;
|
gcc_assert (ASM_OPERANDS_LABEL_LENGTH (asmop) == 1);
|
gcc_assert (ASM_OPERANDS_LABEL_LENGTH (asmop) == 1);
|
loc = &ASM_OPERANDS_LABEL (asmop, 0);
|
loc = &ASM_OPERANDS_LABEL (asmop, 0);
|
}
|
}
|
else if (GET_CODE (PATTERN (jump)) == PARALLEL)
|
else 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.
|
NLABEL in JUMP.
|
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;
|
|
|
gcc_assert (JUMP_LABEL (jump) == olabel);
|
gcc_assert (JUMP_LABEL (jump) == olabel);
|
|
|
/* Negative DELETE_UNUSED used to be used to signalize behavior on
|
/* Negative DELETE_UNUSED used to be used to signalize behavior on
|
moving FUNCTION_END note. Just sanity check that no user still worry
|
moving FUNCTION_END note. Just sanity check that no user still worry
|
about this. */
|
about this. */
|
gcc_assert (delete_unused >= 0);
|
gcc_assert (delete_unused >= 0);
|
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 (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 ();
|
if (x == NULL)
|
if (x == NULL)
|
return 0;
|
return 0;
|
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 (const_rtx x, const_rtx y)
|
rtx_renumbered_equal_p (const_rtx x, const_rtx y)
|
{
|
{
|
int i;
|
int i;
|
const enum rtx_code code = GET_CODE (x);
|
const 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;
|
struct subreg_info info;
|
struct subreg_info info;
|
|
|
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)
|
{
|
{
|
subreg_get_info (reg_renumber[reg_x],
|
subreg_get_info (reg_renumber[reg_x],
|
GET_MODE (SUBREG_REG (x)), byte_x,
|
GET_MODE (SUBREG_REG (x)), byte_x,
|
GET_MODE (x), &info);
|
GET_MODE (x), &info);
|
if (!info.representable_p)
|
if (!info.representable_p)
|
return 0;
|
return 0;
|
reg_x = info.offset;
|
reg_x = info.offset;
|
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)
|
{
|
{
|
subreg_get_info (reg_renumber[reg_y],
|
subreg_get_info (reg_renumber[reg_y],
|
GET_MODE (SUBREG_REG (y)), byte_y,
|
GET_MODE (SUBREG_REG (y)), byte_y,
|
GET_MODE (y), &info);
|
GET_MODE (y), &info);
|
if (!info.representable_p)
|
if (!info.representable_p)
|
return 0;
|
return 0;
|
reg_y = info.offset;
|
reg_y = info.offset;
|
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;
|
|
|
/* MEMs refering to different address space are not equivalent. */
|
/* MEMs refering to different address space are not equivalent. */
|
if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
|
if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (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 (const_rtx x)
|
true_regnum (const_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)
|
{
|
{
|
struct subreg_info info;
|
struct subreg_info info;
|
|
|
subreg_get_info (REGNO (SUBREG_REG (x)),
|
subreg_get_info (REGNO (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
GET_MODE (SUBREG_REG (x)),
|
SUBREG_BYTE (x), GET_MODE (x), &info);
|
SUBREG_BYTE (x), GET_MODE (x), &info);
|
|
|
if (info.representable_p)
|
if (info.representable_p)
|
return base + info.offset;
|
return base + info.offset;
|
}
|
}
|
}
|
}
|
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 (const_rtx reg)
|
reg_or_subregno (const_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);
|
}
|
}
|
|
|
