/* CPU mode switching
|
/* CPU mode switching
|
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
|
Copyright (C) 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/>. */
|
|
|
#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 "regs.h"
|
#include "regs.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "real.h"
|
#include "real.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "output.h"
|
#include "output.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "function.h"
|
#include "function.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
|
|
/* We want target macros for the mode switching code to be able to refer
|
/* We want target macros for the mode switching code to be able to refer
|
to instruction attribute values. */
|
to instruction attribute values. */
|
#include "insn-attr.h"
|
#include "insn-attr.h"
|
|
|
#ifdef OPTIMIZE_MODE_SWITCHING
|
#ifdef OPTIMIZE_MODE_SWITCHING
|
|
|
/* The algorithm for setting the modes consists of scanning the insn list
|
/* The algorithm for setting the modes consists of scanning the insn list
|
and finding all the insns which require a specific mode. Each insn gets
|
and finding all the insns which require a specific mode. Each insn gets
|
a unique struct seginfo element. These structures are inserted into a list
|
a unique struct seginfo element. These structures are inserted into a list
|
for each basic block. For each entity, there is an array of bb_info over
|
for each basic block. For each entity, there is an array of bb_info over
|
the flow graph basic blocks (local var 'bb_info'), and contains a list
|
the flow graph basic blocks (local var 'bb_info'), and contains a list
|
of all insns within that basic block, in the order they are encountered.
|
of all insns within that basic block, in the order they are encountered.
|
|
|
For each entity, any basic block WITHOUT any insns requiring a specific
|
For each entity, any basic block WITHOUT any insns requiring a specific
|
mode are given a single entry, without a mode. (Each basic block
|
mode are given a single entry, without a mode. (Each basic block
|
in the flow graph must have at least one entry in the segment table.)
|
in the flow graph must have at least one entry in the segment table.)
|
|
|
The LCM algorithm is then run over the flow graph to determine where to
|
The LCM algorithm is then run over the flow graph to determine where to
|
place the sets to the highest-priority value in respect of first the first
|
place the sets to the highest-priority value in respect of first the first
|
insn in any one block. Any adjustments required to the transparency
|
insn in any one block. Any adjustments required to the transparency
|
vectors are made, then the next iteration starts for the next-lower
|
vectors are made, then the next iteration starts for the next-lower
|
priority mode, till for each entity all modes are exhausted.
|
priority mode, till for each entity all modes are exhausted.
|
|
|
More details are located in the code for optimize_mode_switching(). */
|
More details are located in the code for optimize_mode_switching(). */
|
|
|
/* This structure contains the information for each insn which requires
|
/* This structure contains the information for each insn which requires
|
either single or double mode to be set.
|
either single or double mode to be set.
|
MODE is the mode this insn must be executed in.
|
MODE is the mode this insn must be executed in.
|
INSN_PTR is the insn to be executed (may be the note that marks the
|
INSN_PTR is the insn to be executed (may be the note that marks the
|
beginning of a basic block).
|
beginning of a basic block).
|
BBNUM is the flow graph basic block this insn occurs in.
|
BBNUM is the flow graph basic block this insn occurs in.
|
NEXT is the next insn in the same basic block. */
|
NEXT is the next insn in the same basic block. */
|
struct seginfo
|
struct seginfo
|
{
|
{
|
int mode;
|
int mode;
|
rtx insn_ptr;
|
rtx insn_ptr;
|
int bbnum;
|
int bbnum;
|
struct seginfo *next;
|
struct seginfo *next;
|
HARD_REG_SET regs_live;
|
HARD_REG_SET regs_live;
|
};
|
};
|
|
|
struct bb_info
|
struct bb_info
|
{
|
{
|
struct seginfo *seginfo;
|
struct seginfo *seginfo;
|
int computing;
|
int computing;
|
};
|
};
|
|
|
/* These bitmaps are used for the LCM algorithm. */
|
/* These bitmaps are used for the LCM algorithm. */
|
|
|
static sbitmap *antic;
|
static sbitmap *antic;
|
static sbitmap *transp;
|
static sbitmap *transp;
|
static sbitmap *comp;
|
static sbitmap *comp;
|
|
|
static struct seginfo * new_seginfo (int, rtx, int, HARD_REG_SET);
|
static struct seginfo * new_seginfo (int, rtx, int, HARD_REG_SET);
|
static void add_seginfo (struct bb_info *, struct seginfo *);
|
static void add_seginfo (struct bb_info *, struct seginfo *);
|
static void reg_dies (rtx, HARD_REG_SET);
|
static void reg_dies (rtx, HARD_REG_SET);
|
static void reg_becomes_live (rtx, rtx, void *);
|
static void reg_becomes_live (rtx, rtx, void *);
|
static void make_preds_opaque (basic_block, int);
|
static void make_preds_opaque (basic_block, int);
|
|
|
|
|
/* This function will allocate a new BBINFO structure, initialized
|
/* This function will allocate a new BBINFO structure, initialized
|
with the MODE, INSN, and basic block BB parameters. */
|
with the MODE, INSN, and basic block BB parameters. */
|
|
|
static struct seginfo *
|
static struct seginfo *
|
new_seginfo (int mode, rtx insn, int bb, HARD_REG_SET regs_live)
|
new_seginfo (int mode, rtx insn, int bb, HARD_REG_SET regs_live)
|
{
|
{
|
struct seginfo *ptr;
|
struct seginfo *ptr;
|
ptr = XNEW (struct seginfo);
|
ptr = XNEW (struct seginfo);
|
ptr->mode = mode;
|
ptr->mode = mode;
|
ptr->insn_ptr = insn;
|
ptr->insn_ptr = insn;
|
ptr->bbnum = bb;
|
ptr->bbnum = bb;
|
ptr->next = NULL;
|
ptr->next = NULL;
|
COPY_HARD_REG_SET (ptr->regs_live, regs_live);
|
COPY_HARD_REG_SET (ptr->regs_live, regs_live);
|
return ptr;
|
return ptr;
|
}
|
}
|
|
|
/* Add a seginfo element to the end of a list.
|
/* Add a seginfo element to the end of a list.
|
HEAD is a pointer to the list beginning.
|
HEAD is a pointer to the list beginning.
|
INFO is the structure to be linked in. */
|
INFO is the structure to be linked in. */
|
|
|
static void
|
static void
|
add_seginfo (struct bb_info *head, struct seginfo *info)
|
add_seginfo (struct bb_info *head, struct seginfo *info)
|
{
|
{
|
struct seginfo *ptr;
|
struct seginfo *ptr;
|
|
|
if (head->seginfo == NULL)
|
if (head->seginfo == NULL)
|
head->seginfo = info;
|
head->seginfo = info;
|
else
|
else
|
{
|
{
|
ptr = head->seginfo;
|
ptr = head->seginfo;
|
while (ptr->next != NULL)
|
while (ptr->next != NULL)
|
ptr = ptr->next;
|
ptr = ptr->next;
|
ptr->next = info;
|
ptr->next = info;
|
}
|
}
|
}
|
}
|
|
|
/* Make all predecessors of basic block B opaque, recursively, till we hit
|
/* Make all predecessors of basic block B opaque, recursively, till we hit
|
some that are already non-transparent, or an edge where aux is set; that
|
some that are already non-transparent, or an edge where aux is set; that
|
denotes that a mode set is to be done on that edge.
|
denotes that a mode set is to be done on that edge.
|
J is the bit number in the bitmaps that corresponds to the entity that
|
J is the bit number in the bitmaps that corresponds to the entity that
|
we are currently handling mode-switching for. */
|
we are currently handling mode-switching for. */
|
|
|
static void
|
static void
|
make_preds_opaque (basic_block b, int j)
|
make_preds_opaque (basic_block b, int j)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
FOR_EACH_EDGE (e, ei, b->preds)
|
FOR_EACH_EDGE (e, ei, b->preds)
|
{
|
{
|
basic_block pb = e->src;
|
basic_block pb = e->src;
|
|
|
if (e->aux || ! TEST_BIT (transp[pb->index], j))
|
if (e->aux || ! TEST_BIT (transp[pb->index], j))
|
continue;
|
continue;
|
|
|
RESET_BIT (transp[pb->index], j);
|
RESET_BIT (transp[pb->index], j);
|
make_preds_opaque (pb, j);
|
make_preds_opaque (pb, j);
|
}
|
}
|
}
|
}
|
|
|
/* Record in LIVE that register REG died. */
|
/* Record in LIVE that register REG died. */
|
|
|
static void
|
static void
|
reg_dies (rtx reg, HARD_REG_SET live)
|
reg_dies (rtx reg, HARD_REG_SET live)
|
{
|
{
|
int regno, nregs;
|
int regno, nregs;
|
|
|
if (!REG_P (reg))
|
if (!REG_P (reg))
|
return;
|
return;
|
|
|
regno = REGNO (reg);
|
regno = REGNO (reg);
|
if (regno < FIRST_PSEUDO_REGISTER)
|
if (regno < FIRST_PSEUDO_REGISTER)
|
for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
|
for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
|
nregs--)
|
nregs--)
|
CLEAR_HARD_REG_BIT (live, regno + nregs);
|
CLEAR_HARD_REG_BIT (live, regno + nregs);
|
}
|
}
|
|
|
/* Record in LIVE that register REG became live.
|
/* Record in LIVE that register REG became live.
|
This is called via note_stores. */
|
This is called via note_stores. */
|
|
|
static void
|
static void
|
reg_becomes_live (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *live)
|
reg_becomes_live (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *live)
|
{
|
{
|
int regno, nregs;
|
int regno, nregs;
|
|
|
if (GET_CODE (reg) == SUBREG)
|
if (GET_CODE (reg) == SUBREG)
|
reg = SUBREG_REG (reg);
|
reg = SUBREG_REG (reg);
|
|
|
if (!REG_P (reg))
|
if (!REG_P (reg))
|
return;
|
return;
|
|
|
regno = REGNO (reg);
|
regno = REGNO (reg);
|
if (regno < FIRST_PSEUDO_REGISTER)
|
if (regno < FIRST_PSEUDO_REGISTER)
|
for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
|
for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
|
nregs--)
|
nregs--)
|
SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
|
SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
|
}
|
}
|
|
|
/* Make sure if MODE_ENTRY is defined the MODE_EXIT is defined
|
/* Make sure if MODE_ENTRY is defined the MODE_EXIT is defined
|
and vice versa. */
|
and vice versa. */
|
#if defined (MODE_ENTRY) != defined (MODE_EXIT)
|
#if defined (MODE_ENTRY) != defined (MODE_EXIT)
|
#error "Both MODE_ENTRY and MODE_EXIT must be defined"
|
#error "Both MODE_ENTRY and MODE_EXIT must be defined"
|
#endif
|
#endif
|
|
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
/* Split the fallthrough edge to the exit block, so that we can note
|
/* Split the fallthrough edge to the exit block, so that we can note
|
that there NORMAL_MODE is required. Return the new block if it's
|
that there NORMAL_MODE is required. Return the new block if it's
|
inserted before the exit block. Otherwise return null. */
|
inserted before the exit block. Otherwise return null. */
|
|
|
static basic_block
|
static basic_block
|
create_pre_exit (int n_entities, int *entity_map, const int *num_modes)
|
create_pre_exit (int n_entities, int *entity_map, const int *num_modes)
|
{
|
{
|
edge eg;
|
edge eg;
|
edge_iterator ei;
|
edge_iterator ei;
|
basic_block pre_exit;
|
basic_block pre_exit;
|
|
|
/* The only non-call predecessor at this stage is a block with a
|
/* The only non-call predecessor at this stage is a block with a
|
fallthrough edge; there can be at most one, but there could be
|
fallthrough edge; there can be at most one, but there could be
|
none at all, e.g. when exit is called. */
|
none at all, e.g. when exit is called. */
|
pre_exit = 0;
|
pre_exit = 0;
|
FOR_EACH_EDGE (eg, ei, EXIT_BLOCK_PTR->preds)
|
FOR_EACH_EDGE (eg, ei, EXIT_BLOCK_PTR->preds)
|
if (eg->flags & EDGE_FALLTHRU)
|
if (eg->flags & EDGE_FALLTHRU)
|
{
|
{
|
basic_block src_bb = eg->src;
|
basic_block src_bb = eg->src;
|
regset live_at_end = src_bb->il.rtl->global_live_at_end;
|
regset live_at_end = src_bb->il.rtl->global_live_at_end;
|
rtx last_insn, ret_reg;
|
rtx last_insn, ret_reg;
|
|
|
gcc_assert (!pre_exit);
|
gcc_assert (!pre_exit);
|
/* If this function returns a value at the end, we have to
|
/* If this function returns a value at the end, we have to
|
insert the final mode switch before the return value copy
|
insert the final mode switch before the return value copy
|
to its hard register. */
|
to its hard register. */
|
if (EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 1
|
if (EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 1
|
&& NONJUMP_INSN_P ((last_insn = BB_END (src_bb)))
|
&& NONJUMP_INSN_P ((last_insn = BB_END (src_bb)))
|
&& GET_CODE (PATTERN (last_insn)) == USE
|
&& GET_CODE (PATTERN (last_insn)) == USE
|
&& GET_CODE ((ret_reg = XEXP (PATTERN (last_insn), 0))) == REG)
|
&& GET_CODE ((ret_reg = XEXP (PATTERN (last_insn), 0))) == REG)
|
{
|
{
|
int ret_start = REGNO (ret_reg);
|
int ret_start = REGNO (ret_reg);
|
int nregs = hard_regno_nregs[ret_start][GET_MODE (ret_reg)];
|
int nregs = hard_regno_nregs[ret_start][GET_MODE (ret_reg)];
|
int ret_end = ret_start + nregs;
|
int ret_end = ret_start + nregs;
|
int short_block = 0;
|
int short_block = 0;
|
int maybe_builtin_apply = 0;
|
int maybe_builtin_apply = 0;
|
int forced_late_switch = 0;
|
int forced_late_switch = 0;
|
rtx before_return_copy;
|
rtx before_return_copy;
|
|
|
do
|
do
|
{
|
{
|
rtx return_copy = PREV_INSN (last_insn);
|
rtx return_copy = PREV_INSN (last_insn);
|
rtx return_copy_pat, copy_reg;
|
rtx return_copy_pat, copy_reg;
|
int copy_start, copy_num;
|
int copy_start, copy_num;
|
int j;
|
int j;
|
|
|
if (INSN_P (return_copy))
|
if (INSN_P (return_copy))
|
{
|
{
|
if (GET_CODE (PATTERN (return_copy)) == USE
|
if (GET_CODE (PATTERN (return_copy)) == USE
|
&& GET_CODE (XEXP (PATTERN (return_copy), 0)) == REG
|
&& GET_CODE (XEXP (PATTERN (return_copy), 0)) == REG
|
&& (FUNCTION_VALUE_REGNO_P
|
&& (FUNCTION_VALUE_REGNO_P
|
(REGNO (XEXP (PATTERN (return_copy), 0)))))
|
(REGNO (XEXP (PATTERN (return_copy), 0)))))
|
{
|
{
|
maybe_builtin_apply = 1;
|
maybe_builtin_apply = 1;
|
last_insn = return_copy;
|
last_insn = return_copy;
|
continue;
|
continue;
|
}
|
}
|
/* If the return register is not (in its entirety)
|
/* If the return register is not (in its entirety)
|
likely spilled, the return copy might be
|
likely spilled, the return copy might be
|
partially or completely optimized away. */
|
partially or completely optimized away. */
|
return_copy_pat = single_set (return_copy);
|
return_copy_pat = single_set (return_copy);
|
if (!return_copy_pat)
|
if (!return_copy_pat)
|
{
|
{
|
return_copy_pat = PATTERN (return_copy);
|
return_copy_pat = PATTERN (return_copy);
|
if (GET_CODE (return_copy_pat) != CLOBBER)
|
if (GET_CODE (return_copy_pat) != CLOBBER)
|
break;
|
break;
|
}
|
}
|
copy_reg = SET_DEST (return_copy_pat);
|
copy_reg = SET_DEST (return_copy_pat);
|
if (GET_CODE (copy_reg) == REG)
|
if (GET_CODE (copy_reg) == REG)
|
copy_start = REGNO (copy_reg);
|
copy_start = REGNO (copy_reg);
|
else if (GET_CODE (copy_reg) == SUBREG
|
else if (GET_CODE (copy_reg) == SUBREG
|
&& GET_CODE (SUBREG_REG (copy_reg)) == REG)
|
&& GET_CODE (SUBREG_REG (copy_reg)) == REG)
|
copy_start = REGNO (SUBREG_REG (copy_reg));
|
copy_start = REGNO (SUBREG_REG (copy_reg));
|
else
|
else
|
break;
|
break;
|
if (copy_start >= FIRST_PSEUDO_REGISTER)
|
if (copy_start >= FIRST_PSEUDO_REGISTER)
|
break;
|
break;
|
copy_num
|
copy_num
|
= hard_regno_nregs[copy_start][GET_MODE (copy_reg)];
|
= hard_regno_nregs[copy_start][GET_MODE (copy_reg)];
|
|
|
/* If the return register is not likely spilled, - as is
|
/* If the return register is not likely spilled, - as is
|
the case for floating point on SH4 - then it might
|
the case for floating point on SH4 - then it might
|
be set by an arithmetic operation that needs a
|
be set by an arithmetic operation that needs a
|
different mode than the exit block. */
|
different mode than the exit block. */
|
for (j = n_entities - 1; j >= 0; j--)
|
for (j = n_entities - 1; j >= 0; j--)
|
{
|
{
|
int e = entity_map[j];
|
int e = entity_map[j];
|
int mode = MODE_NEEDED (e, return_copy);
|
int mode = MODE_NEEDED (e, return_copy);
|
|
|
if (mode != num_modes[e] && mode != MODE_EXIT (e))
|
if (mode != num_modes[e] && mode != MODE_EXIT (e))
|
break;
|
break;
|
}
|
}
|
if (j >= 0)
|
if (j >= 0)
|
{
|
{
|
/* For the SH4, floating point loads depend on fpscr,
|
/* For the SH4, floating point loads depend on fpscr,
|
thus we might need to put the final mode switch
|
thus we might need to put the final mode switch
|
after the return value copy. That is still OK,
|
after the return value copy. That is still OK,
|
because a floating point return value does not
|
because a floating point return value does not
|
conflict with address reloads. */
|
conflict with address reloads. */
|
if (copy_start >= ret_start
|
if (copy_start >= ret_start
|
&& copy_start + copy_num <= ret_end
|
&& copy_start + copy_num <= ret_end
|
&& OBJECT_P (SET_SRC (return_copy_pat)))
|
&& OBJECT_P (SET_SRC (return_copy_pat)))
|
forced_late_switch = 1;
|
forced_late_switch = 1;
|
break;
|
break;
|
}
|
}
|
|
|
if (copy_start >= ret_start
|
if (copy_start >= ret_start
|
&& copy_start + copy_num <= ret_end)
|
&& copy_start + copy_num <= ret_end)
|
nregs -= copy_num;
|
nregs -= copy_num;
|
else if (!maybe_builtin_apply
|
else if (!maybe_builtin_apply
|
|| !FUNCTION_VALUE_REGNO_P (copy_start))
|
|| !FUNCTION_VALUE_REGNO_P (copy_start))
|
break;
|
break;
|
last_insn = return_copy;
|
last_insn = return_copy;
|
}
|
}
|
/* ??? Exception handling can lead to the return value
|
/* ??? Exception handling can lead to the return value
|
copy being already separated from the return value use,
|
copy being already separated from the return value use,
|
as in unwind-dw2.c .
|
as in unwind-dw2.c .
|
Similarly, conditionally returning without a value,
|
Similarly, conditionally returning without a value,
|
and conditionally using builtin_return can lead to an
|
and conditionally using builtin_return can lead to an
|
isolated use. */
|
isolated use. */
|
if (return_copy == BB_HEAD (src_bb))
|
if (return_copy == BB_HEAD (src_bb))
|
{
|
{
|
short_block = 1;
|
short_block = 1;
|
break;
|
break;
|
}
|
}
|
last_insn = return_copy;
|
last_insn = return_copy;
|
}
|
}
|
while (nregs);
|
while (nregs);
|
|
|
/* If we didn't see a full return value copy, verify that there
|
/* If we didn't see a full return value copy, verify that there
|
is a plausible reason for this. If some, but not all of the
|
is a plausible reason for this. If some, but not all of the
|
return register is likely spilled, we can expect that there
|
return register is likely spilled, we can expect that there
|
is a copy for the likely spilled part. */
|
is a copy for the likely spilled part. */
|
gcc_assert (!nregs
|
gcc_assert (!nregs
|
|| forced_late_switch
|
|| forced_late_switch
|
|| short_block
|
|| short_block
|
|| !(CLASS_LIKELY_SPILLED_P
|
|| !(CLASS_LIKELY_SPILLED_P
|
(REGNO_REG_CLASS (ret_start)))
|
(REGNO_REG_CLASS (ret_start)))
|
|| (nregs
|
|| (nregs
|
!= hard_regno_nregs[ret_start][GET_MODE (ret_reg)])
|
!= hard_regno_nregs[ret_start][GET_MODE (ret_reg)])
|
/* For multi-hard-register floating point
|
/* For multi-hard-register floating point
|
values, sometimes the likely-spilled part
|
values, sometimes the likely-spilled part
|
is ordinarily copied first, then the other
|
is ordinarily copied first, then the other
|
part is set with an arithmetic operation.
|
part is set with an arithmetic operation.
|
This doesn't actually cause reload
|
This doesn't actually cause reload
|
failures, so let it pass. */
|
failures, so let it pass. */
|
|| (GET_MODE_CLASS (GET_MODE (ret_reg)) != MODE_INT
|
|| (GET_MODE_CLASS (GET_MODE (ret_reg)) != MODE_INT
|
&& nregs != 1));
|
&& nregs != 1));
|
|
|
if (INSN_P (last_insn))
|
if (INSN_P (last_insn))
|
{
|
{
|
before_return_copy
|
before_return_copy
|
= emit_note_before (NOTE_INSN_DELETED, last_insn);
|
= emit_note_before (NOTE_INSN_DELETED, last_insn);
|
/* Instructions preceding LAST_INSN in the same block might
|
/* Instructions preceding LAST_INSN in the same block might
|
require a different mode than MODE_EXIT, so if we might
|
require a different mode than MODE_EXIT, so if we might
|
have such instructions, keep them in a separate block
|
have such instructions, keep them in a separate block
|
from pre_exit. */
|
from pre_exit. */
|
if (last_insn != BB_HEAD (src_bb))
|
if (last_insn != BB_HEAD (src_bb))
|
src_bb = split_block (src_bb,
|
src_bb = split_block (src_bb,
|
PREV_INSN (before_return_copy))->dest;
|
PREV_INSN (before_return_copy))->dest;
|
}
|
}
|
else
|
else
|
before_return_copy = last_insn;
|
before_return_copy = last_insn;
|
pre_exit = split_block (src_bb, before_return_copy)->src;
|
pre_exit = split_block (src_bb, before_return_copy)->src;
|
}
|
}
|
else
|
else
|
{
|
{
|
pre_exit = split_edge (eg);
|
pre_exit = split_edge (eg);
|
COPY_REG_SET (pre_exit->il.rtl->global_live_at_start, live_at_end);
|
COPY_REG_SET (pre_exit->il.rtl->global_live_at_start, live_at_end);
|
COPY_REG_SET (pre_exit->il.rtl->global_live_at_end, live_at_end);
|
COPY_REG_SET (pre_exit->il.rtl->global_live_at_end, live_at_end);
|
}
|
}
|
}
|
}
|
|
|
return pre_exit;
|
return pre_exit;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* Find all insns that need a particular mode setting, and insert the
|
/* Find all insns that need a particular mode setting, and insert the
|
necessary mode switches. Return true if we did work. */
|
necessary mode switches. Return true if we did work. */
|
|
|
static int
|
static int
|
optimize_mode_switching (void)
|
optimize_mode_switching (void)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
int e;
|
int e;
|
basic_block bb;
|
basic_block bb;
|
int need_commit = 0;
|
int need_commit = 0;
|
sbitmap *kill;
|
sbitmap *kill;
|
struct edge_list *edge_list;
|
struct edge_list *edge_list;
|
static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING;
|
static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING;
|
#define N_ENTITIES ARRAY_SIZE (num_modes)
|
#define N_ENTITIES ARRAY_SIZE (num_modes)
|
int entity_map[N_ENTITIES];
|
int entity_map[N_ENTITIES];
|
struct bb_info *bb_info[N_ENTITIES];
|
struct bb_info *bb_info[N_ENTITIES];
|
int i, j;
|
int i, j;
|
int n_entities;
|
int n_entities;
|
int max_num_modes = 0;
|
int max_num_modes = 0;
|
bool emited = false;
|
bool emited = false;
|
basic_block post_entry ATTRIBUTE_UNUSED, pre_exit ATTRIBUTE_UNUSED;
|
basic_block post_entry ATTRIBUTE_UNUSED, pre_exit ATTRIBUTE_UNUSED;
|
|
|
clear_bb_flags ();
|
clear_bb_flags ();
|
|
|
for (e = N_ENTITIES - 1, n_entities = 0; e >= 0; e--)
|
for (e = N_ENTITIES - 1, n_entities = 0; e >= 0; e--)
|
if (OPTIMIZE_MODE_SWITCHING (e))
|
if (OPTIMIZE_MODE_SWITCHING (e))
|
{
|
{
|
int entry_exit_extra = 0;
|
int entry_exit_extra = 0;
|
|
|
/* Create the list of segments within each basic block.
|
/* Create the list of segments within each basic block.
|
If NORMAL_MODE is defined, allow for two extra
|
If NORMAL_MODE is defined, allow for two extra
|
blocks split from the entry and exit block. */
|
blocks split from the entry and exit block. */
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
entry_exit_extra = 3;
|
entry_exit_extra = 3;
|
#endif
|
#endif
|
bb_info[n_entities]
|
bb_info[n_entities]
|
= XCNEWVEC (struct bb_info, last_basic_block + entry_exit_extra);
|
= XCNEWVEC (struct bb_info, last_basic_block + entry_exit_extra);
|
entity_map[n_entities++] = e;
|
entity_map[n_entities++] = e;
|
if (num_modes[e] > max_num_modes)
|
if (num_modes[e] > max_num_modes)
|
max_num_modes = num_modes[e];
|
max_num_modes = num_modes[e];
|
}
|
}
|
|
|
if (! n_entities)
|
if (! n_entities)
|
return 0;
|
return 0;
|
|
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
/* Split the edge from the entry block, so that we can note that
|
/* Split the edge from the entry block, so that we can note that
|
there NORMAL_MODE is supplied. */
|
there NORMAL_MODE is supplied. */
|
post_entry = split_edge (single_succ_edge (ENTRY_BLOCK_PTR));
|
post_entry = split_edge (single_succ_edge (ENTRY_BLOCK_PTR));
|
pre_exit = create_pre_exit (n_entities, entity_map, num_modes);
|
pre_exit = create_pre_exit (n_entities, entity_map, num_modes);
|
#endif
|
#endif
|
|
|
/* Create the bitmap vectors. */
|
/* Create the bitmap vectors. */
|
|
|
antic = sbitmap_vector_alloc (last_basic_block, n_entities);
|
antic = sbitmap_vector_alloc (last_basic_block, n_entities);
|
transp = sbitmap_vector_alloc (last_basic_block, n_entities);
|
transp = sbitmap_vector_alloc (last_basic_block, n_entities);
|
comp = sbitmap_vector_alloc (last_basic_block, n_entities);
|
comp = sbitmap_vector_alloc (last_basic_block, n_entities);
|
|
|
sbitmap_vector_ones (transp, last_basic_block);
|
sbitmap_vector_ones (transp, last_basic_block);
|
|
|
for (j = n_entities - 1; j >= 0; j--)
|
for (j = n_entities - 1; j >= 0; j--)
|
{
|
{
|
int e = entity_map[j];
|
int e = entity_map[j];
|
int no_mode = num_modes[e];
|
int no_mode = num_modes[e];
|
struct bb_info *info = bb_info[j];
|
struct bb_info *info = bb_info[j];
|
|
|
/* Determine what the first use (if any) need for a mode of entity E is.
|
/* Determine what the first use (if any) need for a mode of entity E is.
|
This will be the mode that is anticipatable for this block.
|
This will be the mode that is anticipatable for this block.
|
Also compute the initial transparency settings. */
|
Also compute the initial transparency settings. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
struct seginfo *ptr;
|
struct seginfo *ptr;
|
int last_mode = no_mode;
|
int last_mode = no_mode;
|
HARD_REG_SET live_now;
|
HARD_REG_SET live_now;
|
|
|
REG_SET_TO_HARD_REG_SET (live_now,
|
REG_SET_TO_HARD_REG_SET (live_now,
|
bb->il.rtl->global_live_at_start);
|
bb->il.rtl->global_live_at_start);
|
|
|
/* Pretend the mode is clobbered across abnormal edges. */
|
/* Pretend the mode is clobbered across abnormal edges. */
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
if (e->flags & EDGE_COMPLEX)
|
if (e->flags & EDGE_COMPLEX)
|
break;
|
break;
|
if (e)
|
if (e)
|
{
|
{
|
ptr = new_seginfo (no_mode, BB_HEAD (bb), bb->index, live_now);
|
ptr = new_seginfo (no_mode, BB_HEAD (bb), bb->index, live_now);
|
add_seginfo (info + bb->index, ptr);
|
add_seginfo (info + bb->index, ptr);
|
RESET_BIT (transp[bb->index], j);
|
RESET_BIT (transp[bb->index], j);
|
}
|
}
|
}
|
}
|
|
|
for (insn = BB_HEAD (bb);
|
for (insn = BB_HEAD (bb);
|
insn != NULL && insn != NEXT_INSN (BB_END (bb));
|
insn != NULL && insn != NEXT_INSN (BB_END (bb));
|
insn = NEXT_INSN (insn))
|
insn = NEXT_INSN (insn))
|
{
|
{
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
int mode = MODE_NEEDED (e, insn);
|
int mode = MODE_NEEDED (e, insn);
|
rtx link;
|
rtx link;
|
|
|
if (mode != no_mode && mode != last_mode)
|
if (mode != no_mode && mode != last_mode)
|
{
|
{
|
last_mode = mode;
|
last_mode = mode;
|
ptr = new_seginfo (mode, insn, bb->index, live_now);
|
ptr = new_seginfo (mode, insn, bb->index, live_now);
|
add_seginfo (info + bb->index, ptr);
|
add_seginfo (info + bb->index, ptr);
|
RESET_BIT (transp[bb->index], j);
|
RESET_BIT (transp[bb->index], j);
|
}
|
}
|
#ifdef MODE_AFTER
|
#ifdef MODE_AFTER
|
last_mode = MODE_AFTER (last_mode, insn);
|
last_mode = MODE_AFTER (last_mode, insn);
|
#endif
|
#endif
|
/* Update LIVE_NOW. */
|
/* Update LIVE_NOW. */
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == REG_DEAD)
|
if (REG_NOTE_KIND (link) == REG_DEAD)
|
reg_dies (XEXP (link, 0), live_now);
|
reg_dies (XEXP (link, 0), live_now);
|
|
|
note_stores (PATTERN (insn), reg_becomes_live, &live_now);
|
note_stores (PATTERN (insn), reg_becomes_live, &live_now);
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) == REG_UNUSED)
|
if (REG_NOTE_KIND (link) == REG_UNUSED)
|
reg_dies (XEXP (link, 0), live_now);
|
reg_dies (XEXP (link, 0), live_now);
|
}
|
}
|
}
|
}
|
|
|
info[bb->index].computing = last_mode;
|
info[bb->index].computing = last_mode;
|
/* Check for blocks without ANY mode requirements. */
|
/* Check for blocks without ANY mode requirements. */
|
if (last_mode == no_mode)
|
if (last_mode == no_mode)
|
{
|
{
|
ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now);
|
ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now);
|
add_seginfo (info + bb->index, ptr);
|
add_seginfo (info + bb->index, ptr);
|
}
|
}
|
}
|
}
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
{
|
{
|
int mode = MODE_ENTRY (e);
|
int mode = MODE_ENTRY (e);
|
|
|
if (mode != no_mode)
|
if (mode != no_mode)
|
{
|
{
|
bb = post_entry;
|
bb = post_entry;
|
|
|
/* By always making this nontransparent, we save
|
/* By always making this nontransparent, we save
|
an extra check in make_preds_opaque. We also
|
an extra check in make_preds_opaque. We also
|
need this to avoid confusing pre_edge_lcm when
|
need this to avoid confusing pre_edge_lcm when
|
antic is cleared but transp and comp are set. */
|
antic is cleared but transp and comp are set. */
|
RESET_BIT (transp[bb->index], j);
|
RESET_BIT (transp[bb->index], j);
|
|
|
/* Insert a fake computing definition of MODE into entry
|
/* Insert a fake computing definition of MODE into entry
|
blocks which compute no mode. This represents the mode on
|
blocks which compute no mode. This represents the mode on
|
entry. */
|
entry. */
|
info[bb->index].computing = mode;
|
info[bb->index].computing = mode;
|
|
|
if (pre_exit)
|
if (pre_exit)
|
info[pre_exit->index].seginfo->mode = MODE_EXIT (e);
|
info[pre_exit->index].seginfo->mode = MODE_EXIT (e);
|
}
|
}
|
}
|
}
|
#endif /* NORMAL_MODE */
|
#endif /* NORMAL_MODE */
|
}
|
}
|
|
|
kill = sbitmap_vector_alloc (last_basic_block, n_entities);
|
kill = sbitmap_vector_alloc (last_basic_block, n_entities);
|
for (i = 0; i < max_num_modes; i++)
|
for (i = 0; i < max_num_modes; i++)
|
{
|
{
|
int current_mode[N_ENTITIES];
|
int current_mode[N_ENTITIES];
|
sbitmap *delete;
|
sbitmap *delete;
|
sbitmap *insert;
|
sbitmap *insert;
|
|
|
/* Set the anticipatable and computing arrays. */
|
/* Set the anticipatable and computing arrays. */
|
sbitmap_vector_zero (antic, last_basic_block);
|
sbitmap_vector_zero (antic, last_basic_block);
|
sbitmap_vector_zero (comp, last_basic_block);
|
sbitmap_vector_zero (comp, last_basic_block);
|
for (j = n_entities - 1; j >= 0; j--)
|
for (j = n_entities - 1; j >= 0; j--)
|
{
|
{
|
int m = current_mode[j] = MODE_PRIORITY_TO_MODE (entity_map[j], i);
|
int m = current_mode[j] = MODE_PRIORITY_TO_MODE (entity_map[j], i);
|
struct bb_info *info = bb_info[j];
|
struct bb_info *info = bb_info[j];
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
if (info[bb->index].seginfo->mode == m)
|
if (info[bb->index].seginfo->mode == m)
|
SET_BIT (antic[bb->index], j);
|
SET_BIT (antic[bb->index], j);
|
|
|
if (info[bb->index].computing == m)
|
if (info[bb->index].computing == m)
|
SET_BIT (comp[bb->index], j);
|
SET_BIT (comp[bb->index], j);
|
}
|
}
|
}
|
}
|
|
|
/* Calculate the optimal locations for the
|
/* Calculate the optimal locations for the
|
placement mode switches to modes with priority I. */
|
placement mode switches to modes with priority I. */
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
sbitmap_not (kill[bb->index], transp[bb->index]);
|
sbitmap_not (kill[bb->index], transp[bb->index]);
|
edge_list = pre_edge_lcm (n_entities, transp, comp, antic,
|
edge_list = pre_edge_lcm (n_entities, transp, comp, antic,
|
kill, &insert, &delete);
|
kill, &insert, &delete);
|
|
|
for (j = n_entities - 1; j >= 0; j--)
|
for (j = n_entities - 1; j >= 0; j--)
|
{
|
{
|
/* Insert all mode sets that have been inserted by lcm. */
|
/* Insert all mode sets that have been inserted by lcm. */
|
int no_mode = num_modes[entity_map[j]];
|
int no_mode = num_modes[entity_map[j]];
|
|
|
/* Wherever we have moved a mode setting upwards in the flow graph,
|
/* Wherever we have moved a mode setting upwards in the flow graph,
|
the blocks between the new setting site and the now redundant
|
the blocks between the new setting site and the now redundant
|
computation ceases to be transparent for any lower-priority
|
computation ceases to be transparent for any lower-priority
|
mode of the same entity. First set the aux field of each
|
mode of the same entity. First set the aux field of each
|
insertion site edge non-transparent, then propagate the new
|
insertion site edge non-transparent, then propagate the new
|
non-transparency from the redundant computation upwards till
|
non-transparency from the redundant computation upwards till
|
we hit an insertion site or an already non-transparent block. */
|
we hit an insertion site or an already non-transparent block. */
|
for (e = NUM_EDGES (edge_list) - 1; e >= 0; e--)
|
for (e = NUM_EDGES (edge_list) - 1; e >= 0; e--)
|
{
|
{
|
edge eg = INDEX_EDGE (edge_list, e);
|
edge eg = INDEX_EDGE (edge_list, e);
|
int mode;
|
int mode;
|
basic_block src_bb;
|
basic_block src_bb;
|
HARD_REG_SET live_at_edge;
|
HARD_REG_SET live_at_edge;
|
rtx mode_set;
|
rtx mode_set;
|
|
|
eg->aux = 0;
|
eg->aux = 0;
|
|
|
if (! TEST_BIT (insert[e], j))
|
if (! TEST_BIT (insert[e], j))
|
continue;
|
continue;
|
|
|
eg->aux = (void *)1;
|
eg->aux = (void *)1;
|
|
|
mode = current_mode[j];
|
mode = current_mode[j];
|
src_bb = eg->src;
|
src_bb = eg->src;
|
|
|
REG_SET_TO_HARD_REG_SET (live_at_edge,
|
REG_SET_TO_HARD_REG_SET (live_at_edge,
|
src_bb->il.rtl->global_live_at_end);
|
src_bb->il.rtl->global_live_at_end);
|
|
|
start_sequence ();
|
start_sequence ();
|
EMIT_MODE_SET (entity_map[j], mode, live_at_edge);
|
EMIT_MODE_SET (entity_map[j], mode, live_at_edge);
|
mode_set = get_insns ();
|
mode_set = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
/* Do not bother to insert empty sequence. */
|
/* Do not bother to insert empty sequence. */
|
if (mode_set == NULL_RTX)
|
if (mode_set == NULL_RTX)
|
continue;
|
continue;
|
|
|
/* We should not get an abnormal edge here. */
|
/* We should not get an abnormal edge here. */
|
gcc_assert (! (eg->flags & EDGE_ABNORMAL));
|
gcc_assert (! (eg->flags & EDGE_ABNORMAL));
|
|
|
need_commit = 1;
|
need_commit = 1;
|
insert_insn_on_edge (mode_set, eg);
|
insert_insn_on_edge (mode_set, eg);
|
}
|
}
|
|
|
FOR_EACH_BB_REVERSE (bb)
|
FOR_EACH_BB_REVERSE (bb)
|
if (TEST_BIT (delete[bb->index], j))
|
if (TEST_BIT (delete[bb->index], j))
|
{
|
{
|
make_preds_opaque (bb, j);
|
make_preds_opaque (bb, j);
|
/* Cancel the 'deleted' mode set. */
|
/* Cancel the 'deleted' mode set. */
|
bb_info[j][bb->index].seginfo->mode = no_mode;
|
bb_info[j][bb->index].seginfo->mode = no_mode;
|
}
|
}
|
}
|
}
|
|
|
sbitmap_vector_free (delete);
|
sbitmap_vector_free (delete);
|
sbitmap_vector_free (insert);
|
sbitmap_vector_free (insert);
|
clear_aux_for_edges ();
|
clear_aux_for_edges ();
|
free_edge_list (edge_list);
|
free_edge_list (edge_list);
|
}
|
}
|
|
|
/* Now output the remaining mode sets in all the segments. */
|
/* Now output the remaining mode sets in all the segments. */
|
for (j = n_entities - 1; j >= 0; j--)
|
for (j = n_entities - 1; j >= 0; j--)
|
{
|
{
|
int no_mode = num_modes[entity_map[j]];
|
int no_mode = num_modes[entity_map[j]];
|
|
|
FOR_EACH_BB_REVERSE (bb)
|
FOR_EACH_BB_REVERSE (bb)
|
{
|
{
|
struct seginfo *ptr, *next;
|
struct seginfo *ptr, *next;
|
for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next)
|
for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next)
|
{
|
{
|
next = ptr->next;
|
next = ptr->next;
|
if (ptr->mode != no_mode)
|
if (ptr->mode != no_mode)
|
{
|
{
|
rtx mode_set;
|
rtx mode_set;
|
|
|
start_sequence ();
|
start_sequence ();
|
EMIT_MODE_SET (entity_map[j], ptr->mode, ptr->regs_live);
|
EMIT_MODE_SET (entity_map[j], ptr->mode, ptr->regs_live);
|
mode_set = get_insns ();
|
mode_set = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
/* Insert MODE_SET only if it is nonempty. */
|
/* Insert MODE_SET only if it is nonempty. */
|
if (mode_set != NULL_RTX)
|
if (mode_set != NULL_RTX)
|
{
|
{
|
emited = true;
|
emited = true;
|
if (NOTE_P (ptr->insn_ptr)
|
if (NOTE_P (ptr->insn_ptr)
|
&& (NOTE_LINE_NUMBER (ptr->insn_ptr)
|
&& (NOTE_LINE_NUMBER (ptr->insn_ptr)
|
== NOTE_INSN_BASIC_BLOCK))
|
== NOTE_INSN_BASIC_BLOCK))
|
emit_insn_after (mode_set, ptr->insn_ptr);
|
emit_insn_after (mode_set, ptr->insn_ptr);
|
else
|
else
|
emit_insn_before (mode_set, ptr->insn_ptr);
|
emit_insn_before (mode_set, ptr->insn_ptr);
|
}
|
}
|
}
|
}
|
|
|
free (ptr);
|
free (ptr);
|
}
|
}
|
}
|
}
|
|
|
free (bb_info[j]);
|
free (bb_info[j]);
|
}
|
}
|
|
|
/* Finished. Free up all the things we've allocated. */
|
/* Finished. Free up all the things we've allocated. */
|
|
|
sbitmap_vector_free (kill);
|
sbitmap_vector_free (kill);
|
sbitmap_vector_free (antic);
|
sbitmap_vector_free (antic);
|
sbitmap_vector_free (transp);
|
sbitmap_vector_free (transp);
|
sbitmap_vector_free (comp);
|
sbitmap_vector_free (comp);
|
|
|
if (need_commit)
|
if (need_commit)
|
commit_edge_insertions ();
|
commit_edge_insertions ();
|
|
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
#if defined (MODE_ENTRY) && defined (MODE_EXIT)
|
cleanup_cfg (CLEANUP_NO_INSN_DEL);
|
cleanup_cfg (CLEANUP_NO_INSN_DEL);
|
#else
|
#else
|
if (!need_commit && !emited)
|
if (!need_commit && !emited)
|
return 0;
|
return 0;
|
#endif
|
#endif
|
|
|
max_regno = max_reg_num ();
|
max_regno = max_reg_num ();
|
allocate_reg_info (max_regno, FALSE, FALSE);
|
allocate_reg_info (max_regno, FALSE, FALSE);
|
update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
|
update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
|
(PROP_DEATH_NOTES | PROP_KILL_DEAD_CODE
|
(PROP_DEATH_NOTES | PROP_KILL_DEAD_CODE
|
| PROP_SCAN_DEAD_CODE));
|
| PROP_SCAN_DEAD_CODE));
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
#endif /* OPTIMIZE_MODE_SWITCHING */
|
#endif /* OPTIMIZE_MODE_SWITCHING */
|
|
|
static bool
|
static bool
|
gate_mode_switching (void)
|
gate_mode_switching (void)
|
{
|
{
|
#ifdef OPTIMIZE_MODE_SWITCHING
|
#ifdef OPTIMIZE_MODE_SWITCHING
|
return true;
|
return true;
|
#else
|
#else
|
return false;
|
return false;
|
#endif
|
#endif
|
}
|
}
|
|
|
static unsigned int
|
static unsigned int
|
rest_of_handle_mode_switching (void)
|
rest_of_handle_mode_switching (void)
|
{
|
{
|
#ifdef OPTIMIZE_MODE_SWITCHING
|
#ifdef OPTIMIZE_MODE_SWITCHING
|
no_new_pseudos = 0;
|
no_new_pseudos = 0;
|
optimize_mode_switching ();
|
optimize_mode_switching ();
|
no_new_pseudos = 1;
|
no_new_pseudos = 1;
|
#endif /* OPTIMIZE_MODE_SWITCHING */
|
#endif /* OPTIMIZE_MODE_SWITCHING */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
struct tree_opt_pass pass_mode_switching =
|
struct tree_opt_pass pass_mode_switching =
|
{
|
{
|
"mode-sw", /* name */
|
"mode-sw", /* name */
|
gate_mode_switching, /* gate */
|
gate_mode_switching, /* gate */
|
rest_of_handle_mode_switching, /* execute */
|
rest_of_handle_mode_switching, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_MODE_SWITCH, /* tv_id */
|
TV_MODE_SWITCH, /* 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 */
|
};
|
};
|
|
|
