OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Delete obsolete macros

Browse Source 
From-SVN: r30723
This commit is contained in:
Bernd Schmidt 1999-11-30 12:16:56 +00:00 committed by Bernd Schmidt
parent c219ddf76d
commit 553687c920
11 changed files with 16 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
gcc/ChangeLog
View File

@ -1,3 +1,17 @@
1999-11-30 Bernd Schmidt <bernds@cygnus.co.uk>
* cse.c (FIXED_REGNO_P): Delete tests for OVERLAPPING_REGNO_P.
* global.c (global_alloc): Delete [OVERLAPPING_REGNO_P] code.
* reload.c (find_dummy_reload): Likewise.
(find_equiv_reg): Likewise; also for INSN_CLOBBERS_REGNO_P.
* reload1.c (reload_as_needed): Likewise.
* stupid.c (stupid_find_reg): Likewise.
* tm.texi (Obsolete Register Macros): Delete section.
* gmicro.h: Remove all traces of the two macros.
* i386.h: Likewise.
* m88k.h: Likewise.
* mips.h: Likewise.
1999-11-30 Brendan Kehoe <brendan@cygnus.com>
* sparc.h (MASK_FASTER_STRUCTS, TARGET_FASTER_STRUCTS): Define.

5
gcc/config/gmicro/gmicro.h
View File

@ -237,11 +237,6 @@ extern int target_flags;
/* This Macro is not defined now.
#define CONDITIONAL_REGISTER_USAGE */
/* The Gmicro has no overlapping register */
/* #define OVERLAPPING_REGNO_P(REGNO) */
/* #define INSN_CLOBBERS_REGNO_P(INSN,REGNO) */
/* Return number of consecutive hard regs needed starting at reg REGNO
to hold something of mode MODE.
This is ordinarily the length in words of a value of mode MODE

5
gcc/config/i386/i386.h
View File

@ -909,11 +909,6 @@ enum reg_class
#define CC_REG_P(X) (REG_P (X) && CC_REGNO_P (REGNO (X)))
#define CC_REGNO_P(X) ((X) == FLAGS_REG || (X) == FPSR_REG)
/* 1 if register REGNO can magically overlap other regs.
Note that nonzero values work only in very special circumstances. */
/* #define OVERLAPPING_REGNO_P(REGNO) FP_REGNO_P (REGNO) */
/* The class value for index registers, and the one for base regs. */
#define INDEX_REG_CLASS INDEX_REGS

4
gcc/config/m88k/m88k.h
View File

@ -628,10 +628,6 @@ extern int flag_pic; /* -fpic */
} \
}
/* These interfaces that don't apply to the m88000. */
/* OVERLAPPING_REGNO_P(REGNO) 0 */
/* INSN_CLOBBERS_REGNO_P(INSN, REGNO) 0 */
/* True if register is an extended register. */
#define XRF_REGNO_P(N) ((N) < FIRST_PSEUDO_REGISTER && (N) >= FIRST_EXTENDED_REGISTER)

14
gcc/config/mips/mips.h
View File

@ -2022,20 +2022,6 @@ extern enum reg_class mips_char_to_class[];
#define CLASS_CANNOT_CHANGE_SIZE \
(TARGET_FLOAT64 && ! TARGET_64BIT ? FP_REGS : NO_REGS)
/* If defined, this is a C expression whose value should be
nonzero if the insn INSN has the effect of mysteriously
clobbering the contents of hard register number REGNO. By
"mysterious" we mean that the insn's RTL expression doesn't
describe such an effect.
If this macro is not defined, it means that no insn clobbers
registers mysteriously. This is the usual situation; all else
being equal, it is best for the RTL expression to show all the
activity. */
/* #define INSN_CLOBBERS_REGNO_P(INSN, REGNO) */
/* Stack layout; function entry, exit and calling. */

10
gcc/cse.c
View File

@ -462,18 +462,10 @@ struct table_elt
/* Determine whether register number N is considered a fixed register for CSE.
It is desirable to replace other regs with fixed regs, to reduce need for
non-fixed hard regs.
A reg wins if it is either the frame pointer or designated as fixed,
but not if it is an overlapping register. */
#ifdef OVERLAPPING_REGNO_P
#define FIXED_REGNO_P(N) \
(((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
|| fixed_regs[N] || global_regs[N]) \
&& ! OVERLAPPING_REGNO_P ((N)))
#else
A reg wins if it is either the frame pointer or designated as fixed. */
#define FIXED_REGNO_P(N) \
((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
|| fixed_regs[N] || global_regs[N])
#endif
/* Compute cost of X, as stored in the `cost' field of a table_elt. Fixed
hard registers and pointers into the frame are the cheapest with a cost

5
gcc/global.c
View File

@ -337,11 +337,6 @@ global_alloc (file)
are safe to use only within a basic block. */
CLEAR_HARD_REG_SET (no_global_alloc_regs);
#ifdef OVERLAPPING_REGNO_P
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (OVERLAPPING_REGNO_P (i))
SET_HARD_REG_BIT (no_global_alloc_regs, i);
#endif
/* Build the regset of all eliminable registers and show we can't use those
that we already know won't be eliminated. */

30
gcc/reload.c
View File

@ -1842,11 +1842,6 @@ find_dummy_reload (real_in, real_out, inloc, outloc,
*inloc = const0_rtx;
if (regno < FIRST_PSEUDO_REGISTER
/* A fixed reg that can overlap other regs better not be used
for reloading in any way. */
#ifdef OVERLAPPING_REGNO_P
&& ! (fixed_regs[regno] && OVERLAPPING_REGNO_P (regno))
#endif
&& ! refers_to_regno_for_reload_p (regno, regno + nwords,
PATTERN (this_insn), outloc))
{
@ -6042,15 +6037,6 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
else
return 0;
/* On some machines, certain regs must always be rejected
because they don't behave the way ordinary registers do. */
#ifdef OVERLAPPING_REGNO_P
if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER
&& OVERLAPPING_REGNO_P (regno))
return 0;
#endif
/* Scan insns back from INSN, looking for one that copies
a value into or out of GOAL.
Stop and give up if we reach a label. */
@ -6189,14 +6175,6 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
&& reload_reg_p[valueno] >= 0)
return 0;
/* On some machines, certain regs must always be rejected
because they don't behave the way ordinary registers do. */
#ifdef OVERLAPPING_REGNO_P
if (OVERLAPPING_REGNO_P (valueno))
return 0;
#endif
nregs = HARD_REGNO_NREGS (regno, mode);
valuenregs = HARD_REGNO_NREGS (valueno, mode);
@ -6252,14 +6230,6 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
return 0;
#endif
#ifdef INSN_CLOBBERS_REGNO_P
if ((valueno >= 0 && valueno < FIRST_PSEUDO_REGISTER
&& INSN_CLOBBERS_REGNO_P (p, valueno))
|| (regno >= 0 && regno < FIRST_PSEUDO_REGISTER
&& INSN_CLOBBERS_REGNO_P (p, regno)))
return 0;
#endif
if (GET_RTX_CLASS (GET_CODE (p)) == 'i')
{
pat = PATTERN (p);

12
gcc/reload1.c
View File

@ -4302,7 +4302,7 @@ reload_as_needed (live_known)
int live_known;
{
struct insn_chain *chain;
#if defined (AUTO_INC_DEC) || defined (INSN_CLOBBERS_REGNO_P)
#if defined (AUTO_INC_DEC)
register int i;
#endif
rtx x;
@ -4562,16 +4562,6 @@ reload_as_needed (live_known)
if it is a call-used reg. */
else if (GET_CODE (insn) == CALL_INSN)
AND_COMPL_HARD_REG_SET(reg_reloaded_valid, call_used_reg_set);
/* In case registers overlap, allow certain insns to invalidate
particular hard registers. */
#ifdef INSN_CLOBBERS_REGNO_P
for (i = 0 ; i < FIRST_PSEUDO_REGISTER; i++)
if (TEST_HARD_REG_BIT (reg_reloaded_valid, i)
&& INSN_CLOBBERS_REGNO_P (insn, i))
CLEAR_HARD_REG_BIT (reg_reloaded_valid, i);
#endif
}
/* Clean up. */

9
gcc/stupid.c
View File

@ -542,15 +542,6 @@ stupid_find_reg (call_preserved, class, mode,
int regno = i;
#endif
/* If a register has screwy overlap problems,
don't use it at all if not optimizing.
Actually this is only for the 387 stack register,
and it's because subsequent code won't work. */
#ifdef OVERLAPPING_REGNO_P
if (OVERLAPPING_REGNO_P (regno))
continue;
#endif
if (! TEST_HARD_REG_BIT (used, regno)
&& HARD_REGNO_MODE_OK (regno, mode))
{

38
gcc/tm.texi
View File

@ -1307,7 +1307,6 @@ For returning values in registers, see @ref{Scalar Return}.
* Values in Registers:: What kinds of values each reg can hold.
* Leaf Functions:: Renumbering registers for leaf functions.
* Stack Registers:: Handling a register stack such as 80387.
* Obsolete Register Macros:: Macros formerly used for the 80387.
@end menu
@node Register Basics
@ -1689,43 +1688,6 @@ The number of the last stack-like register. This one is the bottom of
the stack.
@end table
@node Obsolete Register Macros
@subsection Obsolete Macros for Controlling Register Usage
These features do not work very well. They exist because they used to
be required to generate correct code for the 80387 coprocessor of the
80386. They are no longer used by that machine description and may be
removed in a later version of the compiler. Don't use them!
@table @code
@findex OVERLAPPING_REGNO_P
@item OVERLAPPING_REGNO_P (@var{regno})
If defined, this is a C expression whose value is nonzero if hard
register number @var{regno} is an overlapping register. This means a
hard register which overlaps a hard register with a different number.
(Such overlap is undesirable, but occasionally it allows a machine to
be supported which otherwise could not be.) This macro must return
nonzero for @emph{all} the registers which overlap each other. GCC
can use an overlapping register only in certain limited ways. It can
be used for allocation within a basic block, and may be spilled for
reloading; that is all.
If this macro is not defined, it means that none of the hard registers
overlap each other. This is the usual situation.
@findex INSN_CLOBBERS_REGNO_P
@item INSN_CLOBBERS_REGNO_P (@var{insn}, @var{regno})
If defined, this is a C expression whose value should be nonzero if
the insn @var{insn} has the effect of mysteriously clobbering the
contents of hard register number @var{regno}. By ``mysterious'' we
mean that the insn's RTL expression doesn't describe such an effect.
If this macro is not defined, it means that no insn clobbers registers
mysteriously. This is the usual situation; all else being equal,
it is best for the RTL expression to show all the activity.
@end table
@node Register Classes
@section Register Classes
@cindex register class definitions