2000-04-05 02:32:45 +02:00
|
|
|
|
/* Register renaming for the GNU compiler.
|
2001-05-19 07:59:52 +02:00
|
|
|
|
Copyright (C) 2000, 2001 Free Software Foundation, Inc.
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
Makefile.in, [...]: replace "GNU CC" with "GCC".
* Makefile.in, alias.c, basic-block.h, bb-reorder.c, bitmap.c,
bitmap.h, builtin-types.def, builtins.c, builtins.def,
c-aux-info.c, c-common.c, c-common.def, c-common.h,
c-convert.c, c-decl.c, c-dump.c, c-dump.h, c-errors.c,
c-format.c, c-lang.c, c-lex.c, c-lex.h, c-parse.in,
c-pragma.c, c-pragma.h, c-semantics.c, c-tree.h, c-typeck.c,
caller-save.c, calls.c, collect2.c, collect2.h, combine.c,
conditions.h, config.gcc, configure.frag, configure.in,
conflict.c, convert.c, convert.h, cppspec.c, crtstuff.c,
cse.c, cselib.c, cselib.h, dbxout.c, dbxout.h, defaults.h,
dependence.c, df.c, df.h, diagnostic.c, diagnostic.h,
doloop.c, dominance.c, dwarf.h, dwarf2.h, dwarf2asm.c,
dwarf2asm.h, dwarf2out.c, dwarf2out.h, dwarfout.c,
emit-rtl.c, errors.c, errors.h, except.c, except.h,
exgettext, explow.c, expmed.c, expr.c, expr.h, final.c,
fixproto, flags.h, flow.c, fold-const.c, fp-test.c,
function.c, function.h, gbl-ctors.h, gcc.c, gcc.h, gcc.hlp,
gccspec.c, gcov-io.h, gcse.c, genattr.c, genattrtab.c,
gencheck.c, gencodes.c, genconfig.c, genemit.c,
genextract.c, genflags.c, gengenrtl.c, genmultilib,
genopinit.c, genoutput.c, genpeep.c, genrecog.c,
gensupport.c, gensupport.h, ggc-callbacks.c, ggc-common.c,
ggc-none.c, ggc-page.c, ggc-simple.c, ggc.h, global.c,
graph.c, graph.h, gthr-aix.h, gthr-dce.h, gthr-posix.h,
gthr-rtems.h, gthr-single.h, gthr-solaris.h, gthr-vxworks.h,
gthr-win32.h, gthr.h, haifa-sched.c, halfpic.c, halfpic.h,
hard-reg-set.h, hwint.h, ifcvt.c, input.h, insn-addr.h,
integrate.c, integrate.h, jump.c, lcm.c, libgcc2.c,
libgcc2.h, lists.c, local-alloc.c, loop.c, loop.h,
machmode.def, machmode.h, main.c, mbchar.c, mbchar.h,
mips-tdump.c, mips-tfile.c, mklibgcc.in, mkmap-flat.awk,
mkmap-symver.awk, optabs.c, output.h, params.c, params.def,
params.h, predict.c, predict.def, predict.h, prefix.c,
prefix.h, print-rtl.c, print-tree.c, profile.c, protoize.c,
read-rtl.c, real.c, real.h, recog.c, recog.h, reg-stack.c,
regclass.c, regmove.c, regrename.c, regs.h, reload.c,
reload.h, reload1.c, reorg.c, resource.c, resource.h, rtl.c,
rtl.def, rtl.h, rtlanal.c, sbitmap.c, sbitmap.h,
sched-deps.c, sched-ebb.c, sched-int.h, sched-rgn.c,
sched-vis.c, sdbout.c, sdbout.h, sibcall.c, simplify-rtx.c,
ssa-ccp.c, ssa-dce.c, ssa.c, ssa.h, stmt.c, stor-layout.c,
stringpool.c, system.h, timevar.c, timevar.def, timevar.h,
tlink.c, toplev.c, toplev.h, tree.c, tree.def, tree.h,
tsystem.h, unroll.c, unwind-dw2-fde.c, unwind-dw2-fde.h,
unwind-dw2.c, unwind-pe.h, unwind-sjlj.c, unwind.h,
unwind.inc, varasm.c, varray.c, varray.h, xcoffout.c,
xcoffout.h: replace "GNU CC" with "GCC".
From-SVN: r45105
2001-08-22 16:35:51 +02:00
|
|
|
|
This file is part of GCC.
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
Makefile.in, [...]: replace "GNU CC" with "GCC".
* Makefile.in, alias.c, basic-block.h, bb-reorder.c, bitmap.c,
bitmap.h, builtin-types.def, builtins.c, builtins.def,
c-aux-info.c, c-common.c, c-common.def, c-common.h,
c-convert.c, c-decl.c, c-dump.c, c-dump.h, c-errors.c,
c-format.c, c-lang.c, c-lex.c, c-lex.h, c-parse.in,
c-pragma.c, c-pragma.h, c-semantics.c, c-tree.h, c-typeck.c,
caller-save.c, calls.c, collect2.c, collect2.h, combine.c,
conditions.h, config.gcc, configure.frag, configure.in,
conflict.c, convert.c, convert.h, cppspec.c, crtstuff.c,
cse.c, cselib.c, cselib.h, dbxout.c, dbxout.h, defaults.h,
dependence.c, df.c, df.h, diagnostic.c, diagnostic.h,
doloop.c, dominance.c, dwarf.h, dwarf2.h, dwarf2asm.c,
dwarf2asm.h, dwarf2out.c, dwarf2out.h, dwarfout.c,
emit-rtl.c, errors.c, errors.h, except.c, except.h,
exgettext, explow.c, expmed.c, expr.c, expr.h, final.c,
fixproto, flags.h, flow.c, fold-const.c, fp-test.c,
function.c, function.h, gbl-ctors.h, gcc.c, gcc.h, gcc.hlp,
gccspec.c, gcov-io.h, gcse.c, genattr.c, genattrtab.c,
gencheck.c, gencodes.c, genconfig.c, genemit.c,
genextract.c, genflags.c, gengenrtl.c, genmultilib,
genopinit.c, genoutput.c, genpeep.c, genrecog.c,
gensupport.c, gensupport.h, ggc-callbacks.c, ggc-common.c,
ggc-none.c, ggc-page.c, ggc-simple.c, ggc.h, global.c,
graph.c, graph.h, gthr-aix.h, gthr-dce.h, gthr-posix.h,
gthr-rtems.h, gthr-single.h, gthr-solaris.h, gthr-vxworks.h,
gthr-win32.h, gthr.h, haifa-sched.c, halfpic.c, halfpic.h,
hard-reg-set.h, hwint.h, ifcvt.c, input.h, insn-addr.h,
integrate.c, integrate.h, jump.c, lcm.c, libgcc2.c,
libgcc2.h, lists.c, local-alloc.c, loop.c, loop.h,
machmode.def, machmode.h, main.c, mbchar.c, mbchar.h,
mips-tdump.c, mips-tfile.c, mklibgcc.in, mkmap-flat.awk,
mkmap-symver.awk, optabs.c, output.h, params.c, params.def,
params.h, predict.c, predict.def, predict.h, prefix.c,
prefix.h, print-rtl.c, print-tree.c, profile.c, protoize.c,
read-rtl.c, real.c, real.h, recog.c, recog.h, reg-stack.c,
regclass.c, regmove.c, regrename.c, regs.h, reload.c,
reload.h, reload1.c, reorg.c, resource.c, resource.h, rtl.c,
rtl.def, rtl.h, rtlanal.c, sbitmap.c, sbitmap.h,
sched-deps.c, sched-ebb.c, sched-int.h, sched-rgn.c,
sched-vis.c, sdbout.c, sdbout.h, sibcall.c, simplify-rtx.c,
ssa-ccp.c, ssa-dce.c, ssa.c, ssa.h, stmt.c, stor-layout.c,
stringpool.c, system.h, timevar.c, timevar.def, timevar.h,
tlink.c, toplev.c, toplev.h, tree.c, tree.def, tree.h,
tsystem.h, unroll.c, unwind-dw2-fde.c, unwind-dw2-fde.h,
unwind-dw2.c, unwind-pe.h, unwind-sjlj.c, unwind.h,
unwind.inc, varasm.c, varray.c, varray.h, xcoffout.c,
xcoffout.h: replace "GNU CC" with "GCC".
From-SVN: r45105
2001-08-22 16:35:51 +02:00
|
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
|
|
|
|
under the terms of the GNU General Public License as published by
|
2000-04-05 02:32:45 +02:00
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
|
any later version.
|
|
|
|
|
|
Makefile.in, [...]: replace "GNU CC" with "GCC".
* Makefile.in, alias.c, basic-block.h, bb-reorder.c, bitmap.c,
bitmap.h, builtin-types.def, builtins.c, builtins.def,
c-aux-info.c, c-common.c, c-common.def, c-common.h,
c-convert.c, c-decl.c, c-dump.c, c-dump.h, c-errors.c,
c-format.c, c-lang.c, c-lex.c, c-lex.h, c-parse.in,
c-pragma.c, c-pragma.h, c-semantics.c, c-tree.h, c-typeck.c,
caller-save.c, calls.c, collect2.c, collect2.h, combine.c,
conditions.h, config.gcc, configure.frag, configure.in,
conflict.c, convert.c, convert.h, cppspec.c, crtstuff.c,
cse.c, cselib.c, cselib.h, dbxout.c, dbxout.h, defaults.h,
dependence.c, df.c, df.h, diagnostic.c, diagnostic.h,
doloop.c, dominance.c, dwarf.h, dwarf2.h, dwarf2asm.c,
dwarf2asm.h, dwarf2out.c, dwarf2out.h, dwarfout.c,
emit-rtl.c, errors.c, errors.h, except.c, except.h,
exgettext, explow.c, expmed.c, expr.c, expr.h, final.c,
fixproto, flags.h, flow.c, fold-const.c, fp-test.c,
function.c, function.h, gbl-ctors.h, gcc.c, gcc.h, gcc.hlp,
gccspec.c, gcov-io.h, gcse.c, genattr.c, genattrtab.c,
gencheck.c, gencodes.c, genconfig.c, genemit.c,
genextract.c, genflags.c, gengenrtl.c, genmultilib,
genopinit.c, genoutput.c, genpeep.c, genrecog.c,
gensupport.c, gensupport.h, ggc-callbacks.c, ggc-common.c,
ggc-none.c, ggc-page.c, ggc-simple.c, ggc.h, global.c,
graph.c, graph.h, gthr-aix.h, gthr-dce.h, gthr-posix.h,
gthr-rtems.h, gthr-single.h, gthr-solaris.h, gthr-vxworks.h,
gthr-win32.h, gthr.h, haifa-sched.c, halfpic.c, halfpic.h,
hard-reg-set.h, hwint.h, ifcvt.c, input.h, insn-addr.h,
integrate.c, integrate.h, jump.c, lcm.c, libgcc2.c,
libgcc2.h, lists.c, local-alloc.c, loop.c, loop.h,
machmode.def, machmode.h, main.c, mbchar.c, mbchar.h,
mips-tdump.c, mips-tfile.c, mklibgcc.in, mkmap-flat.awk,
mkmap-symver.awk, optabs.c, output.h, params.c, params.def,
params.h, predict.c, predict.def, predict.h, prefix.c,
prefix.h, print-rtl.c, print-tree.c, profile.c, protoize.c,
read-rtl.c, real.c, real.h, recog.c, recog.h, reg-stack.c,
regclass.c, regmove.c, regrename.c, regs.h, reload.c,
reload.h, reload1.c, reorg.c, resource.c, resource.h, rtl.c,
rtl.def, rtl.h, rtlanal.c, sbitmap.c, sbitmap.h,
sched-deps.c, sched-ebb.c, sched-int.h, sched-rgn.c,
sched-vis.c, sdbout.c, sdbout.h, sibcall.c, simplify-rtx.c,
ssa-ccp.c, ssa-dce.c, ssa.c, ssa.h, stmt.c, stor-layout.c,
stringpool.c, system.h, timevar.c, timevar.def, timevar.h,
tlink.c, toplev.c, toplev.h, tree.c, tree.def, tree.h,
tsystem.h, unroll.c, unwind-dw2-fde.c, unwind-dw2-fde.h,
unwind-dw2.c, unwind-pe.h, unwind-sjlj.c, unwind.h,
unwind.inc, varasm.c, varray.c, varray.h, xcoffout.c,
xcoffout.h: replace "GNU CC" with "GCC".
From-SVN: r45105
2001-08-22 16:35:51 +02:00
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
|
|
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|
|
|
|
License for more details.
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
Makefile.in, [...]: replace "GNU CC" with "GCC".
* Makefile.in, alias.c, basic-block.h, bb-reorder.c, bitmap.c,
bitmap.h, builtin-types.def, builtins.c, builtins.def,
c-aux-info.c, c-common.c, c-common.def, c-common.h,
c-convert.c, c-decl.c, c-dump.c, c-dump.h, c-errors.c,
c-format.c, c-lang.c, c-lex.c, c-lex.h, c-parse.in,
c-pragma.c, c-pragma.h, c-semantics.c, c-tree.h, c-typeck.c,
caller-save.c, calls.c, collect2.c, collect2.h, combine.c,
conditions.h, config.gcc, configure.frag, configure.in,
conflict.c, convert.c, convert.h, cppspec.c, crtstuff.c,
cse.c, cselib.c, cselib.h, dbxout.c, dbxout.h, defaults.h,
dependence.c, df.c, df.h, diagnostic.c, diagnostic.h,
doloop.c, dominance.c, dwarf.h, dwarf2.h, dwarf2asm.c,
dwarf2asm.h, dwarf2out.c, dwarf2out.h, dwarfout.c,
emit-rtl.c, errors.c, errors.h, except.c, except.h,
exgettext, explow.c, expmed.c, expr.c, expr.h, final.c,
fixproto, flags.h, flow.c, fold-const.c, fp-test.c,
function.c, function.h, gbl-ctors.h, gcc.c, gcc.h, gcc.hlp,
gccspec.c, gcov-io.h, gcse.c, genattr.c, genattrtab.c,
gencheck.c, gencodes.c, genconfig.c, genemit.c,
genextract.c, genflags.c, gengenrtl.c, genmultilib,
genopinit.c, genoutput.c, genpeep.c, genrecog.c,
gensupport.c, gensupport.h, ggc-callbacks.c, ggc-common.c,
ggc-none.c, ggc-page.c, ggc-simple.c, ggc.h, global.c,
graph.c, graph.h, gthr-aix.h, gthr-dce.h, gthr-posix.h,
gthr-rtems.h, gthr-single.h, gthr-solaris.h, gthr-vxworks.h,
gthr-win32.h, gthr.h, haifa-sched.c, halfpic.c, halfpic.h,
hard-reg-set.h, hwint.h, ifcvt.c, input.h, insn-addr.h,
integrate.c, integrate.h, jump.c, lcm.c, libgcc2.c,
libgcc2.h, lists.c, local-alloc.c, loop.c, loop.h,
machmode.def, machmode.h, main.c, mbchar.c, mbchar.h,
mips-tdump.c, mips-tfile.c, mklibgcc.in, mkmap-flat.awk,
mkmap-symver.awk, optabs.c, output.h, params.c, params.def,
params.h, predict.c, predict.def, predict.h, prefix.c,
prefix.h, print-rtl.c, print-tree.c, profile.c, protoize.c,
read-rtl.c, real.c, real.h, recog.c, recog.h, reg-stack.c,
regclass.c, regmove.c, regrename.c, regs.h, reload.c,
reload.h, reload1.c, reorg.c, resource.c, resource.h, rtl.c,
rtl.def, rtl.h, rtlanal.c, sbitmap.c, sbitmap.h,
sched-deps.c, sched-ebb.c, sched-int.h, sched-rgn.c,
sched-vis.c, sdbout.c, sdbout.h, sibcall.c, simplify-rtx.c,
ssa-ccp.c, ssa-dce.c, ssa.c, ssa.h, stmt.c, stor-layout.c,
stringpool.c, system.h, timevar.c, timevar.def, timevar.h,
tlink.c, toplev.c, toplev.h, tree.c, tree.def, tree.h,
tsystem.h, unroll.c, unwind-dw2-fde.c, unwind-dw2-fde.h,
unwind-dw2.c, unwind-pe.h, unwind-sjlj.c, unwind.h,
unwind.inc, varasm.c, varray.c, varray.h, xcoffout.c,
xcoffout.h: replace "GNU CC" with "GCC".
From-SVN: r45105
2001-08-22 16:35:51 +02:00
|
|
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
|
|
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
|
|
|
02111-1307, USA. */
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#define REG_OK_STRICT
|
|
|
|
|
|
2000-04-05 02:32:45 +02:00
|
|
|
|
#include "config.h"
|
|
|
|
|
#include "system.h"
|
|
|
|
|
#include "rtl.h"
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#include "tm_p.h"
|
2000-04-05 02:32:45 +02:00
|
|
|
|
#include "insn-config.h"
|
|
|
|
|
#include "regs.h"
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#include "hard-reg-set.h"
|
|
|
|
|
#include "basic-block.h"
|
|
|
|
|
#include "reload.h"
|
2000-04-05 02:32:45 +02:00
|
|
|
|
#include "output.h"
|
|
|
|
|
#include "function.h"
|
|
|
|
|
#include "recog.h"
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#include "flags.h"
|
regrename.c (copyprop_hardreg_forward): New optimization.
* regrename.c (copyprop_hardreg_forward): New optimization.
(kill_value_regno, kill_value, init_value_data, kill_clobbered_value,
kill_set_value, kill_autoinc_value, copy_value, find_oldest_value_reg,
replace_oldest_value_reg, replace_oldest_value_addr,
replace_oldest_value_mem, copyprop_hardreg_forward_1,
debug_value_data, validate_value_data): New.
* rtl.h (copyprop_hardreg_forward): Declare.
* toplev.c (flag_cprop_registers): New.
(f_options): Add -fcprop-registers
(rest_of_compilation): Invoke it.
(parse_options_and_default_flags): Set it at -O1.
* doc/invoke.texi: Document it.
From-SVN: r47951
2001-12-12 23:50:05 +01:00
|
|
|
|
#include "toplev.h"
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#include "obstack.h"
|
|
|
|
|
|
|
|
|
|
#define obstack_chunk_alloc xmalloc
|
|
|
|
|
#define obstack_chunk_free free
|
|
|
|
|
|
|
|
|
|
#ifndef REGNO_MODE_OK_FOR_BASE_P
|
|
|
|
|
#define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) REGNO_OK_FOR_BASE_P (REGNO)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef REG_MODE_OK_FOR_BASE_P
|
|
|
|
|
#define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
|
|
|
|
|
#endif
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
|
|
|
|
static const char *const reg_class_names[] = REG_CLASS_NAMES;
|
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
struct du_chain
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
struct du_chain *next_chain;
|
|
|
|
|
struct du_chain *next_use;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
rtx insn;
|
|
|
|
|
rtx *loc;
|
|
|
|
|
enum reg_class class;
|
|
|
|
|
unsigned int need_caller_save_reg:1;
|
2000-12-22 16:44:42 +01:00
|
|
|
|
unsigned int earlyclobber:1;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
};
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
enum scan_actions
|
|
|
|
|
{
|
|
|
|
|
terminate_all_read,
|
|
|
|
|
terminate_overlapping_read,
|
|
|
|
|
terminate_write,
|
|
|
|
|
terminate_dead,
|
|
|
|
|
mark_read,
|
|
|
|
|
mark_write
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const char * const scan_actions_name[] =
|
|
|
|
|
{
|
|
|
|
|
"terminate_all_read",
|
|
|
|
|
"terminate_overlapping_read",
|
|
|
|
|
"terminate_write",
|
|
|
|
|
"terminate_dead",
|
|
|
|
|
"mark_read",
|
|
|
|
|
"mark_write"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct obstack rename_obstack;
|
|
|
|
|
|
|
|
|
|
static void do_replace PARAMS ((struct du_chain *, int));
|
|
|
|
|
static void scan_rtx_reg PARAMS ((rtx, rtx *, enum reg_class,
|
2000-12-22 16:44:42 +01:00
|
|
|
|
enum scan_actions, enum op_type, int));
|
2000-10-27 22:58:57 +02:00
|
|
|
|
static void scan_rtx_address PARAMS ((rtx, rtx *, enum reg_class,
|
2000-10-28 23:41:24 +02:00
|
|
|
|
enum scan_actions, enum machine_mode));
|
2000-10-27 22:58:57 +02:00
|
|
|
|
static void scan_rtx PARAMS ((rtx, rtx *, enum reg_class,
|
2000-12-22 16:44:42 +01:00
|
|
|
|
enum scan_actions, enum op_type, int));
|
|
|
|
|
static struct du_chain *build_def_use PARAMS ((basic_block));
|
2000-10-27 22:58:57 +02:00
|
|
|
|
static void dump_def_use_chain PARAMS ((struct du_chain *));
|
2000-12-22 16:44:42 +01:00
|
|
|
|
static void note_sets PARAMS ((rtx, rtx, void *));
|
|
|
|
|
static void clear_dead_regs PARAMS ((HARD_REG_SET *, enum machine_mode, rtx));
|
|
|
|
|
static void merge_overlapping_regs PARAMS ((basic_block, HARD_REG_SET *,
|
|
|
|
|
struct du_chain *));
|
|
|
|
|
|
|
|
|
|
/* Called through note_stores from update_life. Find sets of registers, and
|
|
|
|
|
record them in *DATA (which is actually a HARD_REG_SET *). */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
note_sets (x, set, data)
|
|
|
|
|
rtx x;
|
|
|
|
|
rtx set ATTRIBUTE_UNUSED;
|
|
|
|
|
void *data;
|
|
|
|
|
{
|
|
|
|
|
HARD_REG_SET *pset = (HARD_REG_SET *) data;
|
|
|
|
|
unsigned int regno;
|
|
|
|
|
int nregs;
|
|
|
|
|
if (GET_CODE (x) != REG)
|
|
|
|
|
return;
|
|
|
|
|
regno = REGNO (x);
|
|
|
|
|
nregs = HARD_REGNO_NREGS (regno, GET_MODE (x));
|
2001-09-29 23:52:12 +02:00
|
|
|
|
|
|
|
|
|
/* There must not be pseudos at this point. */
|
|
|
|
|
if (regno + nregs > FIRST_PSEUDO_REGISTER)
|
|
|
|
|
abort ();
|
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
while (nregs-- > 0)
|
|
|
|
|
SET_HARD_REG_BIT (*pset, regno + nregs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Clear all registers from *PSET for which a note of kind KIND can be found
|
|
|
|
|
in the list NOTES. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
clear_dead_regs (pset, kind, notes)
|
|
|
|
|
HARD_REG_SET *pset;
|
|
|
|
|
enum machine_mode kind;
|
|
|
|
|
rtx notes;
|
|
|
|
|
{
|
|
|
|
|
rtx note;
|
|
|
|
|
for (note = notes; note; note = XEXP (note, 1))
|
|
|
|
|
if (REG_NOTE_KIND (note) == kind && REG_P (XEXP (note, 0)))
|
|
|
|
|
{
|
|
|
|
|
rtx reg = XEXP (note, 0);
|
|
|
|
|
unsigned int regno = REGNO (reg);
|
|
|
|
|
int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
|
2001-09-29 23:52:12 +02:00
|
|
|
|
|
|
|
|
|
/* There must not be pseudos at this point. */
|
|
|
|
|
if (regno + nregs > FIRST_PSEUDO_REGISTER)
|
|
|
|
|
abort ();
|
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
while (nregs-- > 0)
|
|
|
|
|
CLEAR_HARD_REG_BIT (*pset, regno + nregs);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* For a def-use chain CHAIN in basic block B, find which registers overlap
|
|
|
|
|
its lifetime and set the corresponding bits in *PSET. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
merge_overlapping_regs (b, pset, chain)
|
|
|
|
|
basic_block b;
|
|
|
|
|
HARD_REG_SET *pset;
|
|
|
|
|
struct du_chain *chain;
|
|
|
|
|
{
|
|
|
|
|
struct du_chain *t = chain;
|
|
|
|
|
rtx insn;
|
|
|
|
|
HARD_REG_SET live;
|
|
|
|
|
|
|
|
|
|
REG_SET_TO_HARD_REG_SET (live, b->global_live_at_start);
|
|
|
|
|
insn = b->head;
|
|
|
|
|
while (t)
|
|
|
|
|
{
|
|
|
|
|
/* Search forward until the next reference to the register to be
|
|
|
|
|
renamed. */
|
|
|
|
|
while (insn != t->insn)
|
|
|
|
|
{
|
|
|
|
|
if (INSN_P (insn))
|
|
|
|
|
{
|
|
|
|
|
clear_dead_regs (&live, REG_DEAD, REG_NOTES (insn));
|
|
|
|
|
note_stores (PATTERN (insn), note_sets, (void *) &live);
|
|
|
|
|
/* Only record currently live regs if we are inside the
|
|
|
|
|
reg's live range. */
|
|
|
|
|
if (t != chain)
|
|
|
|
|
IOR_HARD_REG_SET (*pset, live);
|
|
|
|
|
clear_dead_regs (&live, REG_UNUSED, REG_NOTES (insn));
|
|
|
|
|
}
|
|
|
|
|
insn = NEXT_INSN (insn);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
IOR_HARD_REG_SET (*pset, live);
|
|
|
|
|
|
|
|
|
|
/* For the last reference, also merge in all registers set in the
|
|
|
|
|
same insn.
|
|
|
|
|
@@@ We only have take earlyclobbered sets into account. */
|
|
|
|
|
if (! t->next_use)
|
|
|
|
|
note_stores (PATTERN (insn), note_sets, (void *) pset);
|
|
|
|
|
|
|
|
|
|
t = t->next_use;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Perform register renaming on the current function. */
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
void
|
|
|
|
|
regrename_optimize ()
|
|
|
|
|
{
|
2000-12-22 16:44:42 +01:00
|
|
|
|
int tick[FIRST_PSEUDO_REGISTER];
|
|
|
|
|
int this_tick = 0;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
int b;
|
|
|
|
|
char *first_obj;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
memset (tick, 0, sizeof tick);
|
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
gcc_obstack_init (&rename_obstack);
|
|
|
|
|
first_obj = (char *) obstack_alloc (&rename_obstack, 0);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (b = 0; b < n_basic_blocks; b++)
|
|
|
|
|
{
|
|
|
|
|
basic_block bb = BASIC_BLOCK (b);
|
|
|
|
|
struct du_chain *all_chains = 0;
|
|
|
|
|
HARD_REG_SET unavailable;
|
|
|
|
|
HARD_REG_SET regs_seen;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
CLEAR_HARD_REG_SET (unavailable);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fprintf (rtl_dump_file, "\nBasic block %d:\n", b);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
all_chains = build_def_use (bb);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
dump_def_use_chain (all_chains);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
CLEAR_HARD_REG_SET (unavailable);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Don't clobber traceback for noreturn functions. */
|
|
|
|
|
if (frame_pointer_needed)
|
|
|
|
|
{
|
2001-05-19 07:59:52 +02:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = HARD_REGNO_NREGS (FRAME_POINTER_REGNUM, Pmode); i--;)
|
|
|
|
|
SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i);
|
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
2001-05-19 07:59:52 +02:00
|
|
|
|
for (i = HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM, Pmode); i--;)
|
|
|
|
|
SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#endif
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
CLEAR_HARD_REG_SET (regs_seen);
|
|
|
|
|
while (all_chains)
|
|
|
|
|
{
|
2000-12-22 16:44:42 +01:00
|
|
|
|
int new_reg, best_new_reg = -1;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
int n_uses;
|
|
|
|
|
struct du_chain *this = all_chains;
|
|
|
|
|
struct du_chain *tmp, *last;
|
|
|
|
|
HARD_REG_SET this_unavailable;
|
2001-07-22 09:10:46 +02:00
|
|
|
|
int reg = REGNO (*this->loc);
|
2000-10-28 23:41:24 +02:00
|
|
|
|
int i;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
all_chains = this->next_chain;
|
2000-12-22 16:44:42 +01:00
|
|
|
|
|
|
|
|
|
#if 0 /* This just disables optimization opportunities. */
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Only rename once we've seen the reg more than once. */
|
|
|
|
|
if (! TEST_HARD_REG_BIT (regs_seen, reg))
|
2000-04-10 13:23:17 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
SET_HARD_REG_BIT (regs_seen, reg);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2000-12-22 16:44:42 +01:00
|
|
|
|
#endif
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2001-01-04 15:17:40 +01:00
|
|
|
|
if (fixed_regs[reg] || global_regs[reg]
|
|
|
|
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
|
|
|
|
|| (frame_pointer_needed && reg == HARD_FRAME_POINTER_REGNUM)
|
|
|
|
|
#else
|
|
|
|
|
|| (frame_pointer_needed && reg == FRAME_POINTER_REGNUM)
|
|
|
|
|
#endif
|
|
|
|
|
)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
continue;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
COPY_HARD_REG_SET (this_unavailable, unavailable);
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Find last entry on chain (which has the need_caller_save bit),
|
|
|
|
|
count number of uses, and narrow the set of registers we can
|
|
|
|
|
use for renaming. */
|
|
|
|
|
n_uses = 0;
|
|
|
|
|
for (last = this; last->next_use; last = last->next_use)
|
|
|
|
|
{
|
|
|
|
|
n_uses++;
|
|
|
|
|
IOR_COMPL_HARD_REG_SET (this_unavailable,
|
|
|
|
|
reg_class_contents[last->class]);
|
2000-04-10 13:23:17 +02:00
|
|
|
|
}
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (n_uses < 1)
|
|
|
|
|
continue;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
IOR_COMPL_HARD_REG_SET (this_unavailable,
|
|
|
|
|
reg_class_contents[last->class]);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
if (this->need_caller_save_reg)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
|
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
merge_overlapping_regs (bb, &this_unavailable, this);
|
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Now potential_regs is a reasonable approximation, let's
|
|
|
|
|
have a closer look at each register still in there. */
|
2001-07-22 09:10:46 +02:00
|
|
|
|
for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++)
|
2000-04-10 13:23:17 +02:00
|
|
|
|
{
|
2001-07-22 09:10:46 +02:00
|
|
|
|
int nregs = HARD_REGNO_NREGS (new_reg, GET_MODE (*this->loc));
|
|
|
|
|
|
2000-10-28 23:41:24 +02:00
|
|
|
|
for (i = nregs - 1; i >= 0; --i)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
|
|
|
|
|
|| fixed_regs[new_reg + i]
|
|
|
|
|
|| global_regs[new_reg + i]
|
2000-10-28 23:41:24 +02:00
|
|
|
|
/* Can't use regs which aren't saved by the prologue. */
|
2000-12-22 16:44:42 +01:00
|
|
|
|
|| (! regs_ever_live[new_reg + i]
|
|
|
|
|
&& ! call_used_regs[new_reg + i])
|
2001-05-14 09:56:57 +02:00
|
|
|
|
#ifdef LEAF_REGISTERS
|
|
|
|
|
/* We can't use a non-leaf register if we're in a
|
|
|
|
|
leaf function. */
|
|
|
|
|
|| (current_function_is_leaf
|
|
|
|
|
&& !LEAF_REGISTERS[new_reg + i])
|
|
|
|
|
#endif
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#ifdef HARD_REGNO_RENAME_OK
|
2000-12-22 16:44:42 +01:00
|
|
|
|
|| ! HARD_REGNO_RENAME_OK (reg + i, new_reg + i)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#endif
|
2000-10-28 23:41:24 +02:00
|
|
|
|
)
|
|
|
|
|
break;
|
|
|
|
|
if (i >= 0)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
continue;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-28 23:41:24 +02:00
|
|
|
|
/* See whether it accepts all modes that occur in
|
|
|
|
|
definition and uses. */
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (tmp = this; tmp; tmp = tmp->next_use)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
if (! HARD_REGNO_MODE_OK (new_reg, GET_MODE (*tmp->loc)))
|
2000-10-27 22:58:57 +02:00
|
|
|
|
break;
|
|
|
|
|
if (! tmp)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
{
|
|
|
|
|
if (best_new_reg == -1
|
|
|
|
|
|| tick[best_new_reg] > tick[new_reg])
|
|
|
|
|
best_new_reg = new_reg;
|
|
|
|
|
}
|
2000-04-10 13:23:17 +02:00
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
{
|
|
|
|
|
fprintf (rtl_dump_file, "Register %s in insn %d",
|
|
|
|
|
reg_names[reg], INSN_UID (last->insn));
|
|
|
|
|
if (last->need_caller_save_reg)
|
|
|
|
|
fprintf (rtl_dump_file, " crosses a call");
|
|
|
|
|
}
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
if (best_new_reg == -1)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
{
|
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fprintf (rtl_dump_file, "; no available registers\n");
|
2000-04-05 02:32:45 +02:00
|
|
|
|
continue;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
do_replace (this, best_new_reg);
|
|
|
|
|
tick[best_new_reg] = this_tick++;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (rtl_dump_file)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
fprintf (rtl_dump_file, ", renamed as %s\n", reg_names[best_new_reg]);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
obstack_free (&rename_obstack, first_obj);
|
|
|
|
|
}
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
obstack_free (&rename_obstack, NULL);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fputc ('\n', rtl_dump_file);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
count_or_remove_death_notes (NULL, 1);
|
|
|
|
|
update_life_info (NULL, UPDATE_LIFE_LOCAL,
|
|
|
|
|
PROP_REG_INFO | PROP_DEATH_NOTES);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2000-10-27 22:58:57 +02:00
|
|
|
|
do_replace (chain, reg)
|
|
|
|
|
struct du_chain *chain;
|
|
|
|
|
int reg;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
while (chain)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-12-29 18:35:57 +01:00
|
|
|
|
unsigned int regno = ORIGINAL_REGNO (*chain->loc);
|
|
|
|
|
*chain->loc = gen_raw_REG (GET_MODE (*chain->loc), reg);
|
2001-01-04 15:17:40 +01:00
|
|
|
|
if (regno >= FIRST_PSEUDO_REGISTER)
|
|
|
|
|
ORIGINAL_REGNO (*chain->loc) = regno;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
chain = chain->next_use;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
static struct du_chain *open_chains;
|
|
|
|
|
static struct du_chain *closed_chains;
|
|
|
|
|
|
|
|
|
|
static void
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx_reg (insn, loc, class, action, type, earlyclobber)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
rtx insn;
|
|
|
|
|
rtx *loc;
|
|
|
|
|
enum reg_class class;
|
|
|
|
|
enum scan_actions action;
|
|
|
|
|
enum op_type type;
|
2000-12-22 16:44:42 +01:00
|
|
|
|
int earlyclobber;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
struct du_chain **p;
|
|
|
|
|
rtx x = *loc;
|
|
|
|
|
enum machine_mode mode = GET_MODE (x);
|
|
|
|
|
int this_regno = REGNO (x);
|
|
|
|
|
int this_nregs = HARD_REGNO_NREGS (this_regno, mode);
|
|
|
|
|
|
|
|
|
|
if (action == mark_write)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (type == OP_OUT)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
struct du_chain *this = (struct du_chain *)
|
|
|
|
|
obstack_alloc (&rename_obstack, sizeof (struct du_chain));
|
|
|
|
|
this->next_use = 0;
|
|
|
|
|
this->next_chain = open_chains;
|
|
|
|
|
this->loc = loc;
|
|
|
|
|
this->insn = insn;
|
|
|
|
|
this->class = class;
|
|
|
|
|
this->need_caller_save_reg = 0;
|
2000-12-22 16:44:42 +01:00
|
|
|
|
this->earlyclobber = earlyclobber;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
open_chains = this;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if ((type == OP_OUT && action != terminate_write)
|
|
|
|
|
|| (type != OP_OUT && action == terminate_write))
|
|
|
|
|
return;
|
2000-05-11 15:52:44 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (p = &open_chains; *p;)
|
2000-05-11 15:52:44 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
struct du_chain *this = *p;
|
|
|
|
|
|
2000-11-15 12:07:44 +01:00
|
|
|
|
/* Check if the chain has been terminated if it has then skip to
|
|
|
|
|
the next chain.
|
2000-10-27 22:58:57 +02:00
|
|
|
|
|
2000-11-15 12:07:44 +01:00
|
|
|
|
This can happen when we've already appended the location to
|
|
|
|
|
the chain in Step 3, but are trying to hide in-out operands
|
|
|
|
|
from terminate_write in Step 5. */
|
2000-05-11 15:52:44 +02:00
|
|
|
|
|
2000-11-15 12:07:44 +01:00
|
|
|
|
if (*this->loc == cc0_rtx)
|
|
|
|
|
p = &this->next_chain;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int regno = REGNO (*this->loc);
|
|
|
|
|
int nregs = HARD_REGNO_NREGS (regno, GET_MODE (*this->loc));
|
|
|
|
|
int exact_match = (regno == this_regno && nregs == this_nregs);
|
|
|
|
|
|
|
|
|
|
if (regno + nregs <= this_regno
|
|
|
|
|
|| this_regno + this_nregs <= regno)
|
2000-11-22 04:19:34 +01:00
|
|
|
|
{
|
|
|
|
|
p = &this->next_chain;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (action == mark_read)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
{
|
2000-11-15 12:07:44 +01:00
|
|
|
|
if (! exact_match)
|
|
|
|
|
abort ();
|
|
|
|
|
|
2000-11-22 04:19:34 +01:00
|
|
|
|
/* ??? Class NO_REGS can happen if the md file makes use of
|
|
|
|
|
EXTRA_CONSTRAINTS to match registers. Which is arguably
|
|
|
|
|
wrong, but there we are. Since we know not what this may
|
|
|
|
|
be replaced with, terminate the chain. */
|
|
|
|
|
if (class != NO_REGS)
|
|
|
|
|
{
|
|
|
|
|
this = (struct du_chain *)
|
|
|
|
|
obstack_alloc (&rename_obstack, sizeof (struct du_chain));
|
2000-12-22 16:44:42 +01:00
|
|
|
|
this->next_use = 0;
|
2000-11-22 04:19:34 +01:00
|
|
|
|
this->next_chain = (*p)->next_chain;
|
|
|
|
|
this->loc = loc;
|
|
|
|
|
this->insn = insn;
|
|
|
|
|
this->class = class;
|
|
|
|
|
this->need_caller_save_reg = 0;
|
2000-12-22 16:44:42 +01:00
|
|
|
|
while (*p)
|
|
|
|
|
p = &(*p)->next_use;
|
2000-11-22 04:19:34 +01:00
|
|
|
|
*p = this;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
2000-11-22 04:19:34 +01:00
|
|
|
|
|
|
|
|
|
if (action != terminate_overlapping_read || ! exact_match)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
{
|
2000-11-15 12:07:44 +01:00
|
|
|
|
struct du_chain *next = this->next_chain;
|
|
|
|
|
|
|
|
|
|
/* Whether the terminated chain can be used for renaming
|
|
|
|
|
depends on the action and this being an exact match.
|
|
|
|
|
In either case, we remove this element from open_chains. */
|
|
|
|
|
|
|
|
|
|
if ((action == terminate_dead || action == terminate_write)
|
|
|
|
|
&& exact_match)
|
|
|
|
|
{
|
|
|
|
|
this->next_chain = closed_chains;
|
|
|
|
|
closed_chains = this;
|
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fprintf (rtl_dump_file,
|
|
|
|
|
"Closing chain %s at insn %d (%s)\n",
|
|
|
|
|
reg_names[REGNO (*this->loc)], INSN_UID (insn),
|
|
|
|
|
scan_actions_name[(int) action]);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fprintf (rtl_dump_file,
|
|
|
|
|
"Discarding chain %s at insn %d (%s)\n",
|
|
|
|
|
reg_names[REGNO (*this->loc)], INSN_UID (insn),
|
|
|
|
|
scan_actions_name[(int) action]);
|
|
|
|
|
}
|
|
|
|
|
*p = next;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
2000-11-15 12:07:44 +01:00
|
|
|
|
else
|
|
|
|
|
p = &this->next_chain;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or
|
|
|
|
|
BASE_REG_CLASS depending on how the register is being considered. */
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-20 19:54:49 +02:00
|
|
|
|
static void
|
2000-10-28 23:41:24 +02:00
|
|
|
|
scan_rtx_address (insn, loc, class, action, mode)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
rtx insn;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
rtx *loc;
|
|
|
|
|
enum reg_class class;
|
|
|
|
|
enum scan_actions action;
|
2000-10-28 23:41:24 +02:00
|
|
|
|
enum machine_mode mode;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
rtx x = *loc;
|
|
|
|
|
RTX_CODE code = GET_CODE (x);
|
|
|
|
|
const char *fmt;
|
|
|
|
|
int i, j;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (action == mark_write)
|
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
switch (code)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case PLUS:
|
|
|
|
|
{
|
|
|
|
|
rtx orig_op0 = XEXP (x, 0);
|
|
|
|
|
rtx orig_op1 = XEXP (x, 1);
|
|
|
|
|
RTX_CODE code0 = GET_CODE (orig_op0);
|
|
|
|
|
RTX_CODE code1 = GET_CODE (orig_op1);
|
|
|
|
|
rtx op0 = orig_op0;
|
|
|
|
|
rtx op1 = orig_op1;
|
|
|
|
|
rtx *locI = NULL;
|
|
|
|
|
rtx *locB = NULL;
|
|
|
|
|
|
|
|
|
|
if (GET_CODE (op0) == SUBREG)
|
|
|
|
|
{
|
|
|
|
|
op0 = SUBREG_REG (op0);
|
|
|
|
|
code0 = GET_CODE (op0);
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (GET_CODE (op1) == SUBREG)
|
|
|
|
|
{
|
|
|
|
|
op1 = SUBREG_REG (op1);
|
|
|
|
|
code1 = GET_CODE (op1);
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|
|
|
|
|
|| code0 == ZERO_EXTEND || code1 == MEM)
|
|
|
|
|
{
|
|
|
|
|
locI = &XEXP (x, 0);
|
|
|
|
|
locB = &XEXP (x, 1);
|
|
|
|
|
}
|
|
|
|
|
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|
|
|
|
|
|| code1 == ZERO_EXTEND || code0 == MEM)
|
|
|
|
|
{
|
|
|
|
|
locI = &XEXP (x, 1);
|
|
|
|
|
locB = &XEXP (x, 0);
|
|
|
|
|
}
|
|
|
|
|
else if (code0 == CONST_INT || code0 == CONST
|
|
|
|
|
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
|
|
|
|
|
locB = &XEXP (x, 1);
|
|
|
|
|
else if (code1 == CONST_INT || code1 == CONST
|
|
|
|
|
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
|
|
|
|
|
locB = &XEXP (x, 0);
|
|
|
|
|
else if (code0 == REG && code1 == REG)
|
|
|
|
|
{
|
|
|
|
|
int index_op;
|
|
|
|
|
|
|
|
|
|
if (REG_OK_FOR_INDEX_P (op0)
|
|
|
|
|
&& REG_MODE_OK_FOR_BASE_P (op1, mode))
|
|
|
|
|
index_op = 0;
|
|
|
|
|
else if (REG_OK_FOR_INDEX_P (op1)
|
|
|
|
|
&& REG_MODE_OK_FOR_BASE_P (op0, mode))
|
|
|
|
|
index_op = 1;
|
|
|
|
|
else if (REG_MODE_OK_FOR_BASE_P (op1, mode))
|
|
|
|
|
index_op = 0;
|
|
|
|
|
else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
|
|
|
|
|
index_op = 1;
|
|
|
|
|
else if (REG_OK_FOR_INDEX_P (op1))
|
|
|
|
|
index_op = 1;
|
|
|
|
|
else
|
|
|
|
|
index_op = 0;
|
|
|
|
|
|
|
|
|
|
locI = &XEXP (x, index_op);
|
|
|
|
|
locB = &XEXP (x, !index_op);
|
|
|
|
|
}
|
|
|
|
|
else if (code0 == REG)
|
|
|
|
|
{
|
|
|
|
|
locI = &XEXP (x, 0);
|
|
|
|
|
locB = &XEXP (x, 1);
|
|
|
|
|
}
|
|
|
|
|
else if (code1 == REG)
|
|
|
|
|
{
|
|
|
|
|
locI = &XEXP (x, 1);
|
|
|
|
|
locB = &XEXP (x, 0);
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (locI)
|
2000-10-28 23:41:24 +02:00
|
|
|
|
scan_rtx_address (insn, locI, INDEX_REG_CLASS, action, mode);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (locB)
|
2000-10-28 23:41:24 +02:00
|
|
|
|
scan_rtx_address (insn, locB, BASE_REG_CLASS, action, mode);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case POST_INC:
|
|
|
|
|
case POST_DEC:
|
|
|
|
|
case POST_MODIFY:
|
|
|
|
|
case PRE_INC:
|
|
|
|
|
case PRE_DEC:
|
|
|
|
|
case PRE_MODIFY:
|
|
|
|
|
#ifndef AUTO_INC_DEC
|
2000-10-29 06:41:44 +01:00
|
|
|
|
/* If the target doesn't claim to handle autoinc, this must be
|
|
|
|
|
something special, like a stack push. Kill this chain. */
|
|
|
|
|
action = terminate_all_read;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
#endif
|
|
|
|
|
break;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case MEM:
|
2000-10-28 23:41:24 +02:00
|
|
|
|
scan_rtx_address (insn, &XEXP (x, 0), BASE_REG_CLASS, action,
|
|
|
|
|
GET_MODE (x));
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case REG:
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx_reg (insn, loc, class, action, OP_IN, 0);
|
2000-10-20 19:54:49 +02:00
|
|
|
|
return;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
default:
|
|
|
|
|
break;
|
2000-10-20 19:54:49 +02:00
|
|
|
|
}
|
2000-10-27 22:58:57 +02:00
|
|
|
|
|
|
|
|
|
fmt = GET_RTX_FORMAT (code);
|
|
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
2000-10-20 19:54:49 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (fmt[i] == 'e')
|
2000-10-28 23:41:24 +02:00
|
|
|
|
scan_rtx_address (insn, &XEXP (x, i), class, action, mode);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
else if (fmt[i] == 'E')
|
|
|
|
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
2000-10-28 23:41:24 +02:00
|
|
|
|
scan_rtx_address (insn, &XVECEXP (x, i, j), class, action, mode);
|
2000-10-20 19:54:49 +02:00
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
static void
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, loc, class, action, type, earlyclobber)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
rtx insn;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
rtx *loc;
|
|
|
|
|
enum reg_class class;
|
|
|
|
|
enum scan_actions action;
|
|
|
|
|
enum op_type type;
|
2000-12-22 16:44:42 +01:00
|
|
|
|
int earlyclobber;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
const char *fmt;
|
|
|
|
|
rtx x = *loc;
|
|
|
|
|
enum rtx_code code = GET_CODE (x);
|
|
|
|
|
int i, j;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
code = GET_CODE (x);
|
|
|
|
|
switch (code)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case CONST:
|
|
|
|
|
case CONST_INT:
|
|
|
|
|
case CONST_DOUBLE:
|
|
|
|
|
case SYMBOL_REF:
|
|
|
|
|
case LABEL_REF:
|
|
|
|
|
case CC0:
|
|
|
|
|
case PC:
|
|
|
|
|
return;
|
2000-04-05 03:23:57 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case REG:
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx_reg (insn, loc, class, action, type, earlyclobber);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case MEM:
|
2000-10-28 23:41:24 +02:00
|
|
|
|
scan_rtx_address (insn, &XEXP (x, 0), BASE_REG_CLASS, action,
|
|
|
|
|
GET_MODE (x));
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case SET:
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &SET_SRC (x), class, action, OP_IN, 0);
|
|
|
|
|
scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 0);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case STRICT_LOW_PART:
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &XEXP (x, 0), class, action, OP_INOUT, earlyclobber);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case ZERO_EXTRACT:
|
|
|
|
|
case SIGN_EXTRACT:
|
|
|
|
|
scan_rtx (insn, &XEXP (x, 0), class, action,
|
2000-12-22 16:44:42 +01:00
|
|
|
|
type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
|
|
|
|
|
scan_rtx (insn, &XEXP (x, 1), class, action, OP_IN, 0);
|
|
|
|
|
scan_rtx (insn, &XEXP (x, 2), class, action, OP_IN, 0);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case POST_INC:
|
|
|
|
|
case PRE_INC:
|
|
|
|
|
case POST_DEC:
|
|
|
|
|
case PRE_DEC:
|
|
|
|
|
case POST_MODIFY:
|
|
|
|
|
case PRE_MODIFY:
|
|
|
|
|
/* Should only happen inside MEM. */
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
case CLOBBER:
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &SET_DEST (x), class, action, OP_OUT, 1);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
case EXPR_LIST:
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &XEXP (x, 0), class, action, type, 0);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (XEXP (x, 1))
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &XEXP (x, 1), class, action, type, 0);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
return;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
fmt = GET_RTX_FORMAT (code);
|
|
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
|
|
|
|
if (fmt[i] == 'e')
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &XEXP (x, i), class, action, type, 0);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
else if (fmt[i] == 'E')
|
|
|
|
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &XVECEXP (x, i, j), class, action, type, 0);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Build def/use chain */
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
static struct du_chain *
|
2000-12-22 16:44:42 +01:00
|
|
|
|
build_def_use (bb)
|
2000-10-27 22:58:57 +02:00
|
|
|
|
basic_block bb;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
rtx insn;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
open_chains = closed_chains = NULL;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (insn = bb->head; ; insn = NEXT_INSN (insn))
|
|
|
|
|
{
|
|
|
|
|
if (INSN_P (insn))
|
|
|
|
|
{
|
|
|
|
|
int n_ops;
|
|
|
|
|
rtx note;
|
|
|
|
|
rtx old_operands[MAX_RECOG_OPERANDS];
|
|
|
|
|
rtx old_dups[MAX_DUP_OPERANDS];
|
|
|
|
|
int i;
|
|
|
|
|
int alt;
|
|
|
|
|
int predicated;
|
|
|
|
|
|
|
|
|
|
/* Process the insn, determining its effect on the def-use
|
|
|
|
|
chains. We perform the following steps with the register
|
|
|
|
|
references in the insn:
|
|
|
|
|
(1) Any read that overlaps an open chain, but doesn't exactly
|
|
|
|
|
match, causes that chain to be closed. We can't deal
|
|
|
|
|
with overlaps yet.
|
|
|
|
|
(2) Any read outside an operand causes any chain it overlaps
|
|
|
|
|
with to be closed, since we can't replace it.
|
|
|
|
|
(3) Any read inside an operand is added if there's already
|
|
|
|
|
an open chain for it.
|
|
|
|
|
(4) For any REG_DEAD note we find, close open chains that
|
|
|
|
|
overlap it.
|
|
|
|
|
(5) For any write we find, close open chains that overlap it.
|
|
|
|
|
(6) For any write we find in an operand, make a new chain.
|
|
|
|
|
(7) For any REG_UNUSED, close any chains we just opened. */
|
|
|
|
|
|
|
|
|
|
extract_insn (insn);
|
|
|
|
|
constrain_operands (1);
|
|
|
|
|
preprocess_constraints ();
|
|
|
|
|
alt = which_alternative;
|
|
|
|
|
n_ops = recog_data.n_operands;
|
|
|
|
|
|
|
|
|
|
/* Simplify the code below by rewriting things to reflect
|
|
|
|
|
matching constraints. Also promote OP_OUT to OP_INOUT
|
|
|
|
|
in predicated instructions. */
|
|
|
|
|
|
|
|
|
|
predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
|
|
|
|
|
for (i = 0; i < n_ops; ++i)
|
2000-04-05 02:32:45 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
int matches = recog_op_alt[i][alt].matches;
|
|
|
|
|
if (matches >= 0)
|
|
|
|
|
recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
|
|
|
|
|
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|
|
|
|
|
|| (predicated && recog_data.operand_type[i] == OP_OUT))
|
|
|
|
|
recog_data.operand_type[i] = OP_INOUT;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Step 1: Close chains for which we have overlapping reads. */
|
|
|
|
|
for (i = 0; i < n_ops; i++)
|
|
|
|
|
scan_rtx (insn, recog_data.operand_loc[i],
|
|
|
|
|
NO_REGS, terminate_overlapping_read,
|
2000-12-22 16:44:42 +01:00
|
|
|
|
recog_data.operand_type[i], 0);
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Step 2: Close chains for which we have reads outside operands.
|
|
|
|
|
We do this by munging all operands into CC0, and closing
|
|
|
|
|
everything remaining. */
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (i = 0; i < n_ops; i++)
|
2000-04-10 13:23:17 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
old_operands[i] = recog_data.operand[i];
|
|
|
|
|
/* Don't squash match_operator or match_parallel here, since
|
|
|
|
|
we don't know that all of the contained registers are
|
|
|
|
|
reachable by proper operands. */
|
|
|
|
|
if (recog_data.constraints[i][0] == '\0')
|
|
|
|
|
continue;
|
|
|
|
|
*recog_data.operand_loc[i] = cc0_rtx;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < recog_data.n_dups; i++)
|
|
|
|
|
{
|
|
|
|
|
old_dups[i] = *recog_data.dup_loc[i];
|
|
|
|
|
*recog_data.dup_loc[i] = cc0_rtx;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_all_read,
|
|
|
|
|
OP_IN, 0);
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (i = 0; i < recog_data.n_dups; i++)
|
|
|
|
|
*recog_data.dup_loc[i] = old_dups[i];
|
|
|
|
|
for (i = 0; i < n_ops; i++)
|
|
|
|
|
*recog_data.operand_loc[i] = old_operands[i];
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Step 2B: Can't rename function call argument registers. */
|
|
|
|
|
if (GET_CODE (insn) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (insn))
|
|
|
|
|
scan_rtx (insn, &CALL_INSN_FUNCTION_USAGE (insn),
|
2000-12-22 16:44:42 +01:00
|
|
|
|
NO_REGS, terminate_all_read, OP_IN, 0);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Step 3: Append to chains for reads inside operands. */
|
|
|
|
|
for (i = 0; i < n_ops + recog_data.n_dups; i++)
|
|
|
|
|
{
|
|
|
|
|
int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops];
|
|
|
|
|
rtx *loc = (i < n_ops
|
|
|
|
|
? recog_data.operand_loc[opn]
|
|
|
|
|
: recog_data.dup_loc[i - n_ops]);
|
|
|
|
|
enum reg_class class = recog_op_alt[opn][alt].class;
|
|
|
|
|
enum op_type type = recog_data.operand_type[opn];
|
|
|
|
|
|
|
|
|
|
/* Don't scan match_operand here, since we've no reg class
|
|
|
|
|
information to pass down. Any operands that we could
|
|
|
|
|
substitute in will be represented elsewhere. */
|
|
|
|
|
if (recog_data.constraints[opn][0] == '\0')
|
|
|
|
|
continue;
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
if (recog_op_alt[opn][alt].is_address)
|
2000-10-28 23:41:24 +02:00
|
|
|
|
scan_rtx_address (insn, loc, class, mark_read, VOIDmode);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
else
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, loc, class, mark_read, type, 0);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-11-10 11:44:42 +01:00
|
|
|
|
/* Step 4: Close chains for registers that die here.
|
|
|
|
|
Also record updates for REG_INC notes. */
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
2000-11-10 11:44:42 +01:00
|
|
|
|
{
|
|
|
|
|
if (REG_NOTE_KIND (note) == REG_DEAD)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
|
|
|
|
|
OP_IN, 0);
|
2000-11-10 11:44:42 +01:00
|
|
|
|
else if (REG_NOTE_KIND (note) == REG_INC)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_read,
|
|
|
|
|
OP_INOUT, 0);
|
2000-11-10 11:44:42 +01:00
|
|
|
|
}
|
2000-04-10 13:23:17 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Step 4B: If this is a call, any chain live at this point
|
|
|
|
|
requires a caller-saved reg. */
|
|
|
|
|
if (GET_CODE (insn) == CALL_INSN)
|
|
|
|
|
{
|
|
|
|
|
struct du_chain *p;
|
|
|
|
|
for (p = open_chains; p; p = p->next_chain)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
p->need_caller_save_reg = 1;
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Step 5: Close open chains that overlap writes. Similar to
|
|
|
|
|
step 2, we hide in-out operands, since we do not want to
|
|
|
|
|
close these chains. */
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (i = 0; i < n_ops; i++)
|
|
|
|
|
{
|
|
|
|
|
old_operands[i] = recog_data.operand[i];
|
|
|
|
|
if (recog_data.operand_type[i] == OP_INOUT)
|
|
|
|
|
*recog_data.operand_loc[i] = cc0_rtx;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < recog_data.n_dups; i++)
|
|
|
|
|
{
|
|
|
|
|
int opn = recog_data.dup_num[i];
|
|
|
|
|
old_dups[i] = *recog_data.dup_loc[i];
|
|
|
|
|
if (recog_data.operand_type[opn] == OP_INOUT)
|
|
|
|
|
*recog_data.dup_loc[i] = cc0_rtx;
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_write, OP_IN, 0);
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
for (i = 0; i < recog_data.n_dups; i++)
|
|
|
|
|
*recog_data.dup_loc[i] = old_dups[i];
|
|
|
|
|
for (i = 0; i < n_ops; i++)
|
|
|
|
|
*recog_data.operand_loc[i] = old_operands[i];
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Step 6: Begin new chains for writes inside operands. */
|
|
|
|
|
/* ??? Many targets have output constraints on the SET_DEST
|
|
|
|
|
of a call insn, which is stupid, since these are certainly
|
|
|
|
|
ABI defined hard registers. Don't change calls at all. */
|
|
|
|
|
if (GET_CODE (insn) != CALL_INSN)
|
|
|
|
|
for (i = 0; i < n_ops + recog_data.n_dups; i++)
|
|
|
|
|
{
|
|
|
|
|
int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops];
|
|
|
|
|
rtx *loc = (i < n_ops
|
|
|
|
|
? recog_data.operand_loc[opn]
|
|
|
|
|
: recog_data.dup_loc[i - n_ops]);
|
|
|
|
|
enum reg_class class = recog_op_alt[opn][alt].class;
|
|
|
|
|
|
|
|
|
|
if (recog_data.operand_type[opn] == OP_OUT)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, loc, class, mark_write, OP_OUT,
|
|
|
|
|
recog_op_alt[opn][alt].earlyclobber);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Step 7: Close chains for registers that were never
|
|
|
|
|
really used here. */
|
|
|
|
|
for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
|
|
|
|
|
if (REG_NOTE_KIND (note) == REG_UNUSED)
|
2000-12-22 16:44:42 +01:00
|
|
|
|
scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
|
|
|
|
|
OP_IN, 0);
|
2000-10-27 22:58:57 +02:00
|
|
|
|
}
|
|
|
|
|
if (insn == bb->end)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Since we close every chain when we find a REG_DEAD note, anything that
|
|
|
|
|
is still open lives past the basic block, so it can't be renamed. */
|
|
|
|
|
return closed_chains;
|
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
/* Dump all def/use chains in CHAINS to RTL_DUMP_FILE. They are
|
|
|
|
|
printed in reverse order as that's how we build them. */
|
2000-04-05 02:32:45 +02:00
|
|
|
|
|
2000-10-27 22:58:57 +02:00
|
|
|
|
static void
|
|
|
|
|
dump_def_use_chain (chains)
|
|
|
|
|
struct du_chain *chains;
|
|
|
|
|
{
|
|
|
|
|
while (chains)
|
2000-04-10 13:23:17 +02:00
|
|
|
|
{
|
2000-10-27 22:58:57 +02:00
|
|
|
|
struct du_chain *this = chains;
|
|
|
|
|
int r = REGNO (*this->loc);
|
|
|
|
|
int nregs = HARD_REGNO_NREGS (r, GET_MODE (*this->loc));
|
|
|
|
|
fprintf (rtl_dump_file, "Register %s (%d):", reg_names[r], nregs);
|
|
|
|
|
while (this)
|
|
|
|
|
{
|
|
|
|
|
fprintf (rtl_dump_file, " %d [%s]", INSN_UID (this->insn),
|
|
|
|
|
reg_class_names[this->class]);
|
|
|
|
|
this = this->next_use;
|
|
|
|
|
}
|
|
|
|
|
fprintf (rtl_dump_file, "\n");
|
|
|
|
|
chains = chains->next_chain;
|
2000-04-10 13:23:17 +02:00
|
|
|
|
}
|
2000-04-05 02:32:45 +02:00
|
|
|
|
}
|
regrename.c (copyprop_hardreg_forward): New optimization.
* regrename.c (copyprop_hardreg_forward): New optimization.
(kill_value_regno, kill_value, init_value_data, kill_clobbered_value,
kill_set_value, kill_autoinc_value, copy_value, find_oldest_value_reg,
replace_oldest_value_reg, replace_oldest_value_addr,
replace_oldest_value_mem, copyprop_hardreg_forward_1,
debug_value_data, validate_value_data): New.
* rtl.h (copyprop_hardreg_forward): Declare.
* toplev.c (flag_cprop_registers): New.
(f_options): Add -fcprop-registers
(rest_of_compilation): Invoke it.
(parse_options_and_default_flags): Set it at -O1.
* doc/invoke.texi: Document it.
From-SVN: r47951
2001-12-12 23:50:05 +01:00
|
|
|
|
|
|
|
|
|
/* The following code does forward propagation of hard register copies.
|
|
|
|
|
The object is to eliminate as many dependencies as possible, so that
|
|
|
|
|
we have the most scheduling freedom. As a side effect, we also clean
|
|
|
|
|
up some silly register allocation decisions made by reload. This
|
|
|
|
|
code may be obsoleted by a new register allocator. */
|
|
|
|
|
|
|
|
|
|
/* For each register, we have a list of registers that contain the same
|
|
|
|
|
value. The OLDEST_REGNO field points to the head of the list, and
|
|
|
|
|
the NEXT_REGNO field runs through the list. The MODE field indicates
|
|
|
|
|
what mode the data is known to be in; this field is VOIDmode when the
|
|
|
|
|
register is not known to contain valid data. */
|
|
|
|
|
|
|
|
|
|
struct value_data_entry
|
|
|
|
|
{
|
|
|
|
|
enum machine_mode mode;
|
|
|
|
|
unsigned int oldest_regno;
|
|
|
|
|
unsigned int next_regno;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct value_data
|
|
|
|
|
{
|
|
|
|
|
struct value_data_entry e[FIRST_PSEUDO_REGISTER];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void kill_value_regno PARAMS ((unsigned, struct value_data *));
|
|
|
|
|
static void kill_value PARAMS ((rtx, struct value_data *));
|
|
|
|
|
static void init_value_data PARAMS ((struct value_data *));
|
|
|
|
|
static void kill_clobbered_value PARAMS ((rtx, rtx, void *));
|
|
|
|
|
static void kill_set_value PARAMS ((rtx, rtx, void *));
|
|
|
|
|
static int kill_autoinc_value PARAMS ((rtx *, void *));
|
|
|
|
|
static void copy_value PARAMS ((rtx, rtx, struct value_data *));
|
|
|
|
|
static rtx find_oldest_value_reg PARAMS ((enum reg_class, unsigned int,
|
|
|
|
|
enum machine_mode,
|
|
|
|
|
struct value_data *));
|
|
|
|
|
static bool replace_oldest_value_reg PARAMS ((rtx *, enum reg_class, rtx,
|
|
|
|
|
struct value_data *));
|
|
|
|
|
static bool replace_oldest_value_addr PARAMS ((rtx *, enum reg_class,
|
|
|
|
|
enum machine_mode, rtx,
|
|
|
|
|
struct value_data *));
|
|
|
|
|
static bool replace_oldest_value_mem PARAMS ((rtx, rtx, struct value_data *));
|
|
|
|
|
static bool copyprop_hardreg_forward_1 PARAMS ((basic_block,
|
|
|
|
|
struct value_data *));
|
|
|
|
|
extern void debug_value_data PARAMS ((struct value_data *));
|
|
|
|
|
#ifdef ENABLE_CHECKING
|
|
|
|
|
static void validate_value_data PARAMS ((struct value_data *));
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Kill register REGNO. This involves removing it from any value lists,
|
|
|
|
|
and resetting the value mode to VOIDmode. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
kill_value_regno (regno, vd)
|
|
|
|
|
unsigned int regno;
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
unsigned int i, next;
|
|
|
|
|
|
|
|
|
|
if (vd->e[regno].oldest_regno != regno)
|
|
|
|
|
{
|
|
|
|
|
for (i = vd->e[regno].oldest_regno;
|
|
|
|
|
vd->e[i].next_regno != regno;
|
|
|
|
|
i = vd->e[i].next_regno)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
next = vd->e[regno].next_regno;
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
vd->e[i].next_regno = next;
|
|
|
|
|
if (next == INVALID_REGNUM)
|
|
|
|
|
break;
|
|
|
|
|
i = next;
|
|
|
|
|
next = vd->e[next].next_regno;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
|
|
|
|
|
{
|
|
|
|
|
for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
|
|
|
|
|
vd->e[i].oldest_regno = next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vd->e[regno].mode = VOIDmode;
|
|
|
|
|
vd->e[regno].oldest_regno = regno;
|
|
|
|
|
vd->e[regno].next_regno = INVALID_REGNUM;
|
|
|
|
|
|
|
|
|
|
#ifdef ENABLE_CHECKING
|
|
|
|
|
validate_value_data (vd);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Kill X. This is a convenience function for kill_value_regno
|
|
|
|
|
so that we don't have to check that X is a register first. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
kill_value (x, vd)
|
|
|
|
|
rtx x;
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
if (REG_P (x))
|
|
|
|
|
kill_value_regno (REGNO (x), vd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Initialize VD such that there are no known relationships between regs. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
init_value_data (vd)
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
|
|
|
|
{
|
|
|
|
|
vd->e[i].mode = VOIDmode;
|
|
|
|
|
vd->e[i].oldest_regno = i;
|
|
|
|
|
vd->e[i].next_regno = INVALID_REGNUM;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Called through note_stores. If X is clobbered, kill its value. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
kill_clobbered_value (x, set, data)
|
|
|
|
|
rtx x;
|
|
|
|
|
rtx set;
|
|
|
|
|
void *data;
|
|
|
|
|
{
|
|
|
|
|
struct value_data *vd = data;
|
|
|
|
|
if (GET_CODE (set) == CLOBBER)
|
|
|
|
|
kill_value (x, vd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Called through note_stores. If X is set, not clobbered, kill its
|
|
|
|
|
current value and install it as the root of its own value list. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
kill_set_value (x, set, data)
|
|
|
|
|
rtx x;
|
|
|
|
|
rtx set;
|
|
|
|
|
void *data;
|
|
|
|
|
{
|
|
|
|
|
struct value_data *vd = data;
|
|
|
|
|
if (GET_CODE (set) != CLOBBER && REG_P (x))
|
|
|
|
|
{
|
|
|
|
|
unsigned int regno = REGNO (x);
|
|
|
|
|
kill_value_regno (regno, vd);
|
|
|
|
|
vd->e[regno].mode = GET_MODE (x);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Called through for_each_rtx. Kill any register used as the base of an
|
|
|
|
|
auto-increment expression, and install that register as the root of its
|
|
|
|
|
own value list. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
kill_autoinc_value (px, data)
|
|
|
|
|
rtx *px;
|
|
|
|
|
void *data;
|
|
|
|
|
{
|
|
|
|
|
rtx x = *px;
|
|
|
|
|
struct value_data *vd = data;
|
|
|
|
|
|
|
|
|
|
if (GET_RTX_CLASS (GET_CODE (x)) == 'a')
|
|
|
|
|
{
|
|
|
|
|
unsigned int regno = REGNO (XEXP (x, 0));
|
|
|
|
|
kill_value_regno (regno, vd);
|
|
|
|
|
vd->e[regno].mode = Pmode;
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Assert that SRC has been copied to DEST. Adjust the data structures
|
|
|
|
|
to reflect that SRC contains an older copy of the shared value. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
copy_value (dest, src, vd)
|
|
|
|
|
rtx dest;
|
|
|
|
|
rtx src;
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
unsigned int dr = REGNO (dest);
|
|
|
|
|
unsigned int sr = REGNO (src);
|
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
|
|
/* ??? At present, it's possible to see noop sets. It'd be nice if
|
|
|
|
|
this were cleaned up beforehand... */
|
|
|
|
|
if (sr == dr)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Do not propagate copies to the stack pointer, as that can leave
|
|
|
|
|
memory accesses with no scheduling dependancy on the stack update. */
|
|
|
|
|
if (dr == STACK_POINTER_REGNUM)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Likewise with the frame pointer, if we're using one. */
|
|
|
|
|
if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* If SRC had no assigned mode (i.e. we didn't know it was live)
|
|
|
|
|
assign it now and assume the value came from an input argument
|
|
|
|
|
or somesuch. */
|
|
|
|
|
if (vd->e[sr].mode == VOIDmode)
|
|
|
|
|
vd->e[sr].mode = vd->e[dr].mode;
|
|
|
|
|
|
|
|
|
|
/* Link DR at the end of the value chain used by SR. */
|
|
|
|
|
|
|
|
|
|
vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
|
|
|
|
|
|
|
|
|
|
for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno)
|
|
|
|
|
continue;
|
|
|
|
|
vd->e[i].next_regno = dr;
|
|
|
|
|
|
|
|
|
|
#ifdef ENABLE_CHECKING
|
|
|
|
|
validate_value_data (vd);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Find the oldest copy of the value contained in REGNO that is in
|
|
|
|
|
register class CLASS and has mode MODE. If found, return an rtx
|
|
|
|
|
of that oldest register, otherwise return NULL. */
|
|
|
|
|
|
|
|
|
|
static rtx
|
|
|
|
|
find_oldest_value_reg (class, regno, mode, vd)
|
|
|
|
|
enum reg_class class;
|
|
|
|
|
unsigned int regno;
|
|
|
|
|
enum machine_mode mode;
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
|
|
for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
|
|
|
|
|
if (vd->e[i].mode == mode
|
|
|
|
|
&& TEST_HARD_REG_BIT (reg_class_contents[class], i))
|
|
|
|
|
return gen_rtx_REG (mode, i);
|
|
|
|
|
|
|
|
|
|
return NULL_RTX;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If possible, replace the register at *LOC with the oldest register
|
|
|
|
|
in register class CLASS. Return true if successfully replaced. */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
replace_oldest_value_reg (loc, class, insn, vd)
|
|
|
|
|
rtx *loc;
|
|
|
|
|
enum reg_class class;
|
|
|
|
|
rtx insn;
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
rtx new = find_oldest_value_reg (class, REGNO (*loc), GET_MODE (*loc), vd);
|
|
|
|
|
if (new)
|
|
|
|
|
{
|
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fprintf (rtl_dump_file, "insn %u: replaced reg %u with %u\n",
|
|
|
|
|
INSN_UID (insn), REGNO (*loc), REGNO (new));
|
|
|
|
|
|
|
|
|
|
*loc = new;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Similar to replace_oldest_value_reg, but *LOC contains an address.
|
|
|
|
|
Adapted from find_reloads_address_1. CLASS is INDEX_REG_CLASS or
|
|
|
|
|
BASE_REG_CLASS depending on how the register is being considered. */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
replace_oldest_value_addr (loc, class, mode, insn, vd)
|
|
|
|
|
rtx *loc;
|
|
|
|
|
enum reg_class class;
|
|
|
|
|
enum machine_mode mode;
|
|
|
|
|
rtx insn;
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
rtx x = *loc;
|
|
|
|
|
RTX_CODE code = GET_CODE (x);
|
|
|
|
|
const char *fmt;
|
|
|
|
|
int i, j;
|
|
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
|
|
switch (code)
|
|
|
|
|
{
|
|
|
|
|
case PLUS:
|
|
|
|
|
{
|
|
|
|
|
rtx orig_op0 = XEXP (x, 0);
|
|
|
|
|
rtx orig_op1 = XEXP (x, 1);
|
|
|
|
|
RTX_CODE code0 = GET_CODE (orig_op0);
|
|
|
|
|
RTX_CODE code1 = GET_CODE (orig_op1);
|
|
|
|
|
rtx op0 = orig_op0;
|
|
|
|
|
rtx op1 = orig_op1;
|
|
|
|
|
rtx *locI = NULL;
|
|
|
|
|
rtx *locB = NULL;
|
|
|
|
|
|
|
|
|
|
if (GET_CODE (op0) == SUBREG)
|
|
|
|
|
{
|
|
|
|
|
op0 = SUBREG_REG (op0);
|
|
|
|
|
code0 = GET_CODE (op0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (GET_CODE (op1) == SUBREG)
|
|
|
|
|
{
|
|
|
|
|
op1 = SUBREG_REG (op1);
|
|
|
|
|
code1 = GET_CODE (op1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
|
|
|
|
|
|| code0 == ZERO_EXTEND || code1 == MEM)
|
|
|
|
|
{
|
|
|
|
|
locI = &XEXP (x, 0);
|
|
|
|
|
locB = &XEXP (x, 1);
|
|
|
|
|
}
|
|
|
|
|
else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
|
|
|
|
|
|| code1 == ZERO_EXTEND || code0 == MEM)
|
|
|
|
|
{
|
|
|
|
|
locI = &XEXP (x, 1);
|
|
|
|
|
locB = &XEXP (x, 0);
|
|
|
|
|
}
|
|
|
|
|
else if (code0 == CONST_INT || code0 == CONST
|
|
|
|
|
|| code0 == SYMBOL_REF || code0 == LABEL_REF)
|
|
|
|
|
locB = &XEXP (x, 1);
|
|
|
|
|
else if (code1 == CONST_INT || code1 == CONST
|
|
|
|
|
|| code1 == SYMBOL_REF || code1 == LABEL_REF)
|
|
|
|
|
locB = &XEXP (x, 0);
|
|
|
|
|
else if (code0 == REG && code1 == REG)
|
|
|
|
|
{
|
|
|
|
|
int index_op;
|
|
|
|
|
|
|
|
|
|
if (REG_OK_FOR_INDEX_P (op0)
|
|
|
|
|
&& REG_MODE_OK_FOR_BASE_P (op1, mode))
|
|
|
|
|
index_op = 0;
|
|
|
|
|
else if (REG_OK_FOR_INDEX_P (op1)
|
|
|
|
|
&& REG_MODE_OK_FOR_BASE_P (op0, mode))
|
|
|
|
|
index_op = 1;
|
|
|
|
|
else if (REG_MODE_OK_FOR_BASE_P (op1, mode))
|
|
|
|
|
index_op = 0;
|
|
|
|
|
else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
|
|
|
|
|
index_op = 1;
|
|
|
|
|
else if (REG_OK_FOR_INDEX_P (op1))
|
|
|
|
|
index_op = 1;
|
|
|
|
|
else
|
|
|
|
|
index_op = 0;
|
|
|
|
|
|
|
|
|
|
locI = &XEXP (x, index_op);
|
|
|
|
|
locB = &XEXP (x, !index_op);
|
|
|
|
|
}
|
|
|
|
|
else if (code0 == REG)
|
|
|
|
|
{
|
|
|
|
|
locI = &XEXP (x, 0);
|
|
|
|
|
locB = &XEXP (x, 1);
|
|
|
|
|
}
|
|
|
|
|
else if (code1 == REG)
|
|
|
|
|
{
|
|
|
|
|
locI = &XEXP (x, 1);
|
|
|
|
|
locB = &XEXP (x, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (locI)
|
|
|
|
|
changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS, mode,
|
|
|
|
|
insn, vd);
|
|
|
|
|
if (locB)
|
|
|
|
|
changed |= replace_oldest_value_addr (locB, BASE_REG_CLASS, mode,
|
|
|
|
|
insn, vd);
|
|
|
|
|
return changed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case POST_INC:
|
|
|
|
|
case POST_DEC:
|
|
|
|
|
case POST_MODIFY:
|
|
|
|
|
case PRE_INC:
|
|
|
|
|
case PRE_DEC:
|
|
|
|
|
case PRE_MODIFY:
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
case MEM:
|
|
|
|
|
return replace_oldest_value_mem (x, insn, vd);
|
|
|
|
|
|
|
|
|
|
case REG:
|
|
|
|
|
return replace_oldest_value_reg (loc, class, insn, vd);
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fmt = GET_RTX_FORMAT (code);
|
|
|
|
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
|
|
|
|
{
|
|
|
|
|
if (fmt[i] == 'e')
|
|
|
|
|
changed |= replace_oldest_value_addr (&XEXP (x, i), class, mode,
|
|
|
|
|
insn, vd);
|
|
|
|
|
else if (fmt[i] == 'E')
|
|
|
|
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
|
|
|
|
changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), class,
|
|
|
|
|
mode, insn, vd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Similar to replace_oldest_value_reg, but X contains a memory. */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
replace_oldest_value_mem (x, insn, vd)
|
|
|
|
|
rtx x;
|
|
|
|
|
rtx insn;
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
return replace_oldest_value_addr (&XEXP (x, 0), BASE_REG_CLASS,
|
|
|
|
|
GET_MODE (x), insn, vd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Perform the forward copy propagation on basic block BB. */
|
|
|
|
|
|
|
|
|
|
static bool
|
|
|
|
|
copyprop_hardreg_forward_1 (bb, vd)
|
|
|
|
|
basic_block bb;
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
bool changed = false;
|
|
|
|
|
rtx insn;
|
|
|
|
|
|
|
|
|
|
for (insn = bb->head; ; insn = NEXT_INSN (insn))
|
|
|
|
|
{
|
|
|
|
|
int n_ops, i, alt, predicated;
|
|
|
|
|
rtx set;
|
|
|
|
|
|
|
|
|
|
if (! INSN_P (insn))
|
|
|
|
|
{
|
|
|
|
|
if (insn == bb->end)
|
|
|
|
|
break;
|
|
|
|
|
else
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set = single_set (insn);
|
|
|
|
|
extract_insn (insn);
|
|
|
|
|
constrain_operands (1);
|
|
|
|
|
preprocess_constraints ();
|
|
|
|
|
alt = which_alternative;
|
|
|
|
|
n_ops = recog_data.n_operands;
|
|
|
|
|
|
|
|
|
|
/* Simplify the code below by rewriting things to reflect
|
|
|
|
|
matching constraints. Also promote OP_OUT to OP_INOUT
|
|
|
|
|
in predicated instructions. */
|
|
|
|
|
|
|
|
|
|
predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
|
|
|
|
|
for (i = 0; i < n_ops; ++i)
|
|
|
|
|
{
|
|
|
|
|
int matches = recog_op_alt[i][alt].matches;
|
|
|
|
|
if (matches >= 0)
|
|
|
|
|
recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
|
|
|
|
|
if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
|
|
|
|
|
|| (predicated && recog_data.operand_type[i] == OP_OUT))
|
|
|
|
|
recog_data.operand_type[i] = OP_INOUT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* For each earlyclobber operand, zap the value data. */
|
|
|
|
|
for (i = 0; i < n_ops; i++)
|
|
|
|
|
if (recog_op_alt[i][alt].earlyclobber)
|
|
|
|
|
kill_value (recog_data.operand[i], vd);
|
|
|
|
|
|
|
|
|
|
/* Within asms, a clobber cannot overlap inputs or outputs.
|
|
|
|
|
I wouldn't think this were true for regular insns, but
|
|
|
|
|
scan_rtx treats them like that... */
|
|
|
|
|
note_stores (PATTERN (insn), kill_clobbered_value, vd);
|
|
|
|
|
|
|
|
|
|
/* Kill all auto-incremented values. */
|
|
|
|
|
/* ??? REG_INC is useless, since stack pushes aren't done that way. */
|
|
|
|
|
for_each_rtx (&PATTERN (insn), kill_autoinc_value, vd);
|
|
|
|
|
|
|
|
|
|
/* Special-case plain move instructions, since we may well
|
|
|
|
|
be able to do the move from a different register class. */
|
|
|
|
|
if (set && REG_P (SET_SRC (set)))
|
|
|
|
|
{
|
|
|
|
|
unsigned int regno = REGNO (SET_SRC (set));
|
|
|
|
|
enum machine_mode mode = GET_MODE (SET_SRC (set));
|
|
|
|
|
unsigned int i;
|
|
|
|
|
rtx new;
|
|
|
|
|
|
|
|
|
|
/* If the destination is also a register, try to find a source
|
|
|
|
|
register in the same class. */
|
|
|
|
|
if (REG_P (SET_DEST (set)))
|
|
|
|
|
{
|
|
|
|
|
new = find_oldest_value_reg (REGNO_REG_CLASS (regno),
|
|
|
|
|
regno, mode, vd);
|
|
|
|
|
if (new && validate_change (insn, &SET_SRC (set), new, 0))
|
|
|
|
|
{
|
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fprintf (rtl_dump_file,
|
|
|
|
|
"insn %u: replaced reg %u with %u\n",
|
|
|
|
|
INSN_UID (insn), regno, REGNO (new));
|
|
|
|
|
changed = true;
|
|
|
|
|
goto did_replacement;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Otherwise, try all valid registers and see if its valid. */
|
|
|
|
|
for (i = vd->e[regno].oldest_regno; i != regno;
|
|
|
|
|
i = vd->e[i].next_regno)
|
|
|
|
|
if (mode == vd->e[regno].mode)
|
|
|
|
|
{
|
|
|
|
|
new = gen_rtx_REG (mode, i);
|
|
|
|
|
if (validate_change (insn, &SET_SRC (set), new, 0))
|
|
|
|
|
{
|
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fprintf (rtl_dump_file,
|
|
|
|
|
"insn %u: replaced reg %u with %u\n",
|
|
|
|
|
INSN_UID (insn), regno, REGNO (new));
|
|
|
|
|
changed = true;
|
|
|
|
|
goto did_replacement;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* For each input operand, replace a hard register with the
|
|
|
|
|
eldest live copy that's in an appropriate register class. */
|
|
|
|
|
for (i = 0; i < n_ops; i++)
|
|
|
|
|
{
|
|
|
|
|
bool replaced = false;
|
|
|
|
|
|
|
|
|
|
/* Don't scan match_operand here, since we've no reg class
|
|
|
|
|
information to pass down. Any operands that we could
|
|
|
|
|
substitute in will be represented elsewhere. */
|
|
|
|
|
if (recog_data.constraints[i][0] == '\0')
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (recog_data.operand_type[i] == OP_IN)
|
|
|
|
|
{
|
|
|
|
|
if (recog_op_alt[i][alt].is_address)
|
|
|
|
|
replaced
|
|
|
|
|
= replace_oldest_value_addr (recog_data.operand_loc[i],
|
|
|
|
|
recog_op_alt[i][alt].class,
|
|
|
|
|
VOIDmode, insn, vd);
|
|
|
|
|
else if (REG_P (recog_data.operand[i]))
|
|
|
|
|
replaced
|
|
|
|
|
= replace_oldest_value_reg (recog_data.operand_loc[i],
|
|
|
|
|
recog_op_alt[i][alt].class,
|
|
|
|
|
insn, vd);
|
|
|
|
|
else if (GET_CODE (recog_data.operand[i]) == MEM)
|
|
|
|
|
replaced = replace_oldest_value_mem (recog_data.operand[i],
|
|
|
|
|
insn, vd);
|
|
|
|
|
}
|
|
|
|
|
else if (GET_CODE (recog_data.operand[i]) == MEM)
|
|
|
|
|
replaced = replace_oldest_value_mem (recog_data.operand[i],
|
|
|
|
|
insn, vd);
|
|
|
|
|
|
|
|
|
|
/* If we performed any replacement, update match_dups. */
|
|
|
|
|
if (replaced)
|
|
|
|
|
{
|
|
|
|
|
int j;
|
|
|
|
|
rtx new;
|
|
|
|
|
|
|
|
|
|
changed = true;
|
|
|
|
|
|
|
|
|
|
new = *recog_data.operand_loc[i];
|
|
|
|
|
recog_data.operand[i] = new;
|
|
|
|
|
for (j = 0; j < recog_data.n_dups; j++)
|
|
|
|
|
if (recog_data.dup_num[j] == i)
|
|
|
|
|
*recog_data.dup_loc[j] = new;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
did_replacement:
|
|
|
|
|
/* Clobber call-clobbered registers. */
|
|
|
|
|
if (GET_CODE (insn) == CALL_INSN)
|
|
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
|
|
|
|
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
|
|
|
|
|
kill_value_regno (i, vd);
|
|
|
|
|
|
|
|
|
|
/* Notice stores. */
|
|
|
|
|
note_stores (PATTERN (insn), kill_set_value, vd);
|
|
|
|
|
|
|
|
|
|
/* Notice copies. */
|
|
|
|
|
if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
|
|
|
|
|
copy_value (SET_DEST (set), SET_SRC (set), vd);
|
|
|
|
|
|
|
|
|
|
if (insn == bb->end)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Main entry point for the forward copy propagation optimization. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
copyprop_hardreg_forward ()
|
|
|
|
|
{
|
|
|
|
|
int b, need_refresh;
|
|
|
|
|
sbitmap refresh_blocks;
|
|
|
|
|
struct value_data *all_vd;
|
|
|
|
|
|
|
|
|
|
refresh_blocks = sbitmap_alloc (n_basic_blocks);
|
|
|
|
|
sbitmap_zero (refresh_blocks);
|
|
|
|
|
need_refresh = 0;
|
|
|
|
|
|
|
|
|
|
all_vd = xmalloc (sizeof (struct value_data) * n_basic_blocks);
|
|
|
|
|
|
|
|
|
|
for (b = 0; b < n_basic_blocks; b++)
|
|
|
|
|
{
|
|
|
|
|
basic_block bb = BASIC_BLOCK (b);
|
|
|
|
|
|
|
|
|
|
/* If a block has a single predecessor, that we've already
|
|
|
|
|
processed, begin with the value data that was live at
|
|
|
|
|
the end of the predecessor block. */
|
|
|
|
|
/* ??? Ought to use more intelligent queueing of blocks. */
|
|
|
|
|
if (bb->pred
|
|
|
|
|
&& ! bb->pred->pred_next
|
|
|
|
|
&& bb->pred->src->index != ENTRY_BLOCK
|
|
|
|
|
&& bb->pred->src->index < b)
|
|
|
|
|
all_vd[b] = all_vd[bb->pred->src->index];
|
|
|
|
|
else
|
|
|
|
|
init_value_data (all_vd + b);
|
|
|
|
|
|
|
|
|
|
if (copyprop_hardreg_forward_1 (bb, all_vd + b))
|
|
|
|
|
{
|
|
|
|
|
SET_BIT (refresh_blocks, b);
|
|
|
|
|
need_refresh = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (need_refresh)
|
|
|
|
|
{
|
|
|
|
|
if (rtl_dump_file)
|
|
|
|
|
fputs ("\n\n", rtl_dump_file);
|
|
|
|
|
|
|
|
|
|
update_life_info (refresh_blocks, UPDATE_LIFE_GLOBAL_RM_NOTES,
|
|
|
|
|
PROP_DEATH_NOTES
|
|
|
|
|
| PROP_SCAN_DEAD_CODE
|
|
|
|
|
| PROP_KILL_DEAD_CODE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sbitmap_free (refresh_blocks);
|
|
|
|
|
free (all_vd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Dump the value chain data to stderr. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
debug_value_data (vd)
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
HARD_REG_SET set;
|
|
|
|
|
unsigned int i, j;
|
|
|
|
|
|
|
|
|
|
CLEAR_HARD_REG_SET (set);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
|
|
|
|
if (vd->e[i].oldest_regno == i)
|
|
|
|
|
{
|
|
|
|
|
if (vd->e[i].mode == VOIDmode)
|
|
|
|
|
{
|
|
|
|
|
if (vd->e[i].next_regno != INVALID_REGNUM)
|
|
|
|
|
fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
|
|
|
|
|
i, vd->e[i].next_regno);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SET_HARD_REG_BIT (set, i);
|
|
|
|
|
fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
|
|
|
|
|
|
|
|
|
|
for (j = vd->e[i].next_regno;
|
|
|
|
|
j != INVALID_REGNUM;
|
|
|
|
|
j = vd->e[j].next_regno)
|
|
|
|
|
{
|
|
|
|
|
if (TEST_HARD_REG_BIT (set, vd->e[j].next_regno))
|
|
|
|
|
{
|
|
|
|
|
fprintf (stderr, "[%u] Loop in regno chain\n", j);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (vd->e[j].oldest_regno != i)
|
|
|
|
|
{
|
|
|
|
|
fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
|
|
|
|
|
j, vd->e[j].oldest_regno);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
SET_HARD_REG_BIT (set, j);
|
|
|
|
|
fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
|
|
|
|
|
}
|
|
|
|
|
fputc ('\n', stderr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
|
|
|
|
if (! TEST_HARD_REG_BIT (set, i)
|
|
|
|
|
&& (vd->e[i].mode != VOIDmode
|
|
|
|
|
|| vd->e[i].oldest_regno != i
|
|
|
|
|
|| vd->e[i].next_regno != INVALID_REGNUM))
|
|
|
|
|
fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
|
|
|
|
|
i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
|
|
|
|
|
vd->e[i].next_regno);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef ENABLE_CHECKING
|
|
|
|
|
static void
|
|
|
|
|
validate_value_data (vd)
|
|
|
|
|
struct value_data *vd;
|
|
|
|
|
{
|
|
|
|
|
HARD_REG_SET set;
|
|
|
|
|
unsigned int i, j;
|
|
|
|
|
|
|
|
|
|
CLEAR_HARD_REG_SET (set);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
|
|
|
|
if (vd->e[i].oldest_regno == i)
|
|
|
|
|
{
|
|
|
|
|
if (vd->e[i].mode == VOIDmode)
|
|
|
|
|
{
|
|
|
|
|
if (vd->e[i].next_regno != INVALID_REGNUM)
|
|
|
|
|
internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
|
|
|
|
|
i, vd->e[i].next_regno);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SET_HARD_REG_BIT (set, i);
|
|
|
|
|
|
|
|
|
|
for (j = vd->e[i].next_regno;
|
|
|
|
|
j != INVALID_REGNUM;
|
|
|
|
|
j = vd->e[j].next_regno)
|
|
|
|
|
{
|
|
|
|
|
if (TEST_HARD_REG_BIT (set, j))
|
|
|
|
|
internal_error ("validate_value_data: Loop in regno chain (%u)",
|
|
|
|
|
j);
|
|
|
|
|
if (vd->e[j].oldest_regno != i)
|
|
|
|
|
internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
|
|
|
|
|
j, vd->e[j].oldest_regno);
|
|
|
|
|
|
|
|
|
|
SET_HARD_REG_BIT (set, j);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
|
|
|
|
|
if (! TEST_HARD_REG_BIT (set, i)
|
|
|
|
|
&& (vd->e[i].mode != VOIDmode
|
|
|
|
|
|| vd->e[i].oldest_regno != i
|
|
|
|
|
|| vd->e[i].next_regno != INVALID_REGNUM))
|
|
|
|
|
internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
|
|
|
|
|
i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
|
|
|
|
|
vd->e[i].next_regno);
|
|
|
|
|
}
|
|
|
|
|
#endif
|