![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to regs.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to regs.h CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Define per-register tables for data flow info and register allocation.
2: Copyright (C) 1987 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21:
22: #define REG_BYTES(R) mode_size[(int) GET_MODE (R)]
23:
24: /* Get the number of consecutive hard regs required to hold the REG rtx R.
25: When something may be an explicit hard reg, REG_SIZE is the only
26: valid way to get this value. You cannot get it from the regno. */
27:
28: #define REG_SIZE(R) \
29: ((mode_size[(int) GET_MODE (R)] + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
30:
31: /* Maximum register number used in this function, plus one. */
32:
33: extern int max_regno;
34:
35: /* Maximum number of SCRATCH rtx's in each block of this function. */
36:
37: extern int max_scratch;
38:
39: /* Indexed by n, gives number of times (REG n) is used or set.
40: References within loops may be counted more times. */
41:
42: extern int *reg_n_refs;
43:
44: /* Indexed by n, gives number of times (REG n) is set. */
45:
46: extern short *reg_n_sets;
47:
48: /* Indexed by N, gives number of insns in which register N dies.
49: Note that if register N is live around loops, it can die
50: in transitions between basic blocks, and that is not counted here.
51: So this is only a reliable indicator of how many regions of life there are
52: for registers that are contained in one basic block. */
53:
54: extern short *reg_n_deaths;
55:
56: /* Get the number of consecutive words required to hold pseudo-reg N. */
57:
58: #define PSEUDO_REGNO_SIZE(N) \
59: ((GET_MODE_SIZE (PSEUDO_REGNO_MODE (N)) + UNITS_PER_WORD - 1) \
60: / UNITS_PER_WORD)
61:
62: /* Get the number of bytes required to hold pseudo-reg N. */
63:
64: #define PSEUDO_REGNO_BYTES(N) \
65: GET_MODE_SIZE (PSEUDO_REGNO_MODE (N))
66:
67: /* Get the machine mode of pseudo-reg N. */
68:
69: #define PSEUDO_REGNO_MODE(N) GET_MODE (regno_reg_rtx[N])
70:
71: /* Indexed by N, gives number of CALL_INSNS across which (REG n) is live. */
72:
73: extern int *reg_n_calls_crossed;
74:
75: /* Total number of instructions at which (REG n) is live.
76: The larger this is, the less priority (REG n) gets for
77: allocation in a hard register (in global-alloc).
78: This is set in flow.c and remains valid for the rest of the compilation
79: of the function; it is used to control register allocation.
80:
81: local-alloc.c may alter this number to change the priority.
82:
83: Negative values are special.
84: -1 is used to mark a pseudo reg which has a constant or memory equivalent
85: and is used infrequently enough that it should not get a hard register.
86: -2 is used to mark a pseudo reg for a parameter, when a frame pointer
1.1.1.2 ! root 87: is not required. global.c makes an allocno for this but does
1.1 root 88: not try to assign a hard register to it. */
89:
90: extern int *reg_live_length;
91:
92: /* Vector of substitutions of register numbers,
93: used to map pseudo regs into hardware regs. */
94:
95: extern short *reg_renumber;
96:
97: /* Vector indexed by hardware reg
98: saying whether that reg is ever used. */
99:
100: extern char regs_ever_live[FIRST_PSEUDO_REGISTER];
101:
102: /* Vector indexed by hardware reg giving its name. */
103:
104: extern char *reg_names[FIRST_PSEUDO_REGISTER];
105:
106: /* Vector indexed by regno; gives uid of first insn using that reg.
107: This is computed by reg_scan for use by cse and loop.
108: It is sometimes adjusted for subsequent changes during loop,
109: but not adjusted by cse even if cse invalidates it. */
110:
1.1.1.2 ! root 111: extern int *regno_first_uid;
1.1 root 112:
113: /* Vector indexed by regno; gives uid of last insn using that reg.
114: This is computed by reg_scan for use by cse and loop.
115: It is sometimes adjusted for subsequent changes during loop,
116: but not adjusted by cse even if cse invalidates it.
117: This is harmless since cse won't scan through a loop end. */
118:
1.1.1.2 ! root 119: extern int *regno_last_uid;
1.1 root 120:
121: /* Vector indexed by regno; contains 1 for a register is considered a pointer.
122: Reloading, etc. will use a pointer register rather than a non-pointer
123: as the base register in an address, when there is a choice of two regs. */
124:
125: extern char *regno_pointer_flag;
126: #define REGNO_POINTER_FLAG(REGNO) regno_pointer_flag[REGNO]
127:
128: /* List made of EXPR_LIST rtx's which gives pairs of pseudo registers
129: that have to go in the same hard reg. */
130: extern rtx regs_may_share;
131:
132: /* Vector mapping pseudo regno into the REG rtx for that register.
133: This is computed by reg_scan. */
134:
135: extern rtx *regno_reg_rtx;
136:
137: /* Flag set by local-alloc or global-alloc if they decide to allocate
138: something in a call-clobbered register. */
139:
140: extern int caller_save_needed;
141:
142: /* Predicate to decide whether to give a hard reg to a pseudo which
143: is referenced REFS times and would need to be saved and restored
144: around a call CALLS times. */
145:
146: #ifndef CALLER_SAVE_PROFITABLE
147: #define CALLER_SAVE_PROFITABLE(REFS, CALLS) (4 * (CALLS) < (REFS))
148: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.