Commit | Line | Data |
---|---|---|
9bf86ebb PR |
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 | |
87 | is not required. global.c makes an allocno for this but does | |
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 | ||
111 | extern int *regno_first_uid; | |
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 | ||
119 | extern int *regno_last_uid; | |
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 |