Branch data Line data Source code
1 : : /* Scanning of rtl for dataflow analysis.
2 : : Copyright (C) 2007-2024 Free Software Foundation, Inc.
3 : : Contributed by Kenneth Zadeck (zadeck@naturalbridge.com).
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it under
8 : : the terms of the GNU General Public License as published by the Free
9 : : Software Foundation; either version 3, or (at your option) any later
10 : : version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : : for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : :
22 : : #include "config.h"
23 : : #include "system.h"
24 : : #include "coretypes.h"
25 : : #include "backend.h"
26 : : #include "rtl.h"
27 : : #include "predict.h"
28 : : #include "df.h"
29 : : #include "regs.h"
30 : :
31 : :
32 : : struct regstat_n_sets_and_refs_t *regstat_n_sets_and_refs;
33 : :
34 : : /*----------------------------------------------------------------------------
35 : : REG_N_SETS and REG_N_REFS.
36 : : ----------------------------------------------------------------------------*/
37 : :
38 : : /* If a pass need to change these values in some magical way or the
39 : : pass needs to have accurate values for these and is not using
40 : : incremental df scanning, then it should use REG_N_SETS and
41 : : REG_N_USES. If the pass is doing incremental scanning then it
42 : : should be getting the info from DF_REG_DEF_COUNT and
43 : : DF_REG_USE_COUNT. */
44 : :
45 : : void
46 : 3439754 : regstat_init_n_sets_and_refs (void)
47 : : {
48 : 3439754 : unsigned int i;
49 : 3439754 : unsigned int max_regno = max_reg_num ();
50 : :
51 : 3439754 : timevar_push (TV_REG_STATS);
52 : 3439754 : df_grow_reg_info ();
53 : 3439754 : gcc_assert (!regstat_n_sets_and_refs);
54 : :
55 : 3439754 : regstat_n_sets_and_refs = XNEWVEC (struct regstat_n_sets_and_refs_t, max_regno);
56 : :
57 : 3439754 : if (MAY_HAVE_DEBUG_BIND_INSNS)
58 : 225372402 : for (i = 0; i < max_regno; i++)
59 : : {
60 : 223920496 : int use_count;
61 : 223920496 : df_ref use;
62 : :
63 : 223920496 : use_count = DF_REG_USE_COUNT (i);
64 : 500666837 : for (use = DF_REG_USE_CHAIN (i); use; use = DF_REF_NEXT_REG (use))
65 : 276746341 : if (DF_REF_INSN_INFO (use) && DEBUG_INSN_P (DF_REF_INSN (use)))
66 : 27503445 : use_count--;
67 : :
68 : :
69 : 223920496 : SET_REG_N_SETS (i, DF_REG_DEF_COUNT (i));
70 : 223920496 : SET_REG_N_REFS (i, use_count + REG_N_SETS (i));
71 : : }
72 : : else
73 : 265313456 : for (i = 0; i < max_regno; i++)
74 : : {
75 : 263325608 : SET_REG_N_SETS (i, DF_REG_DEF_COUNT (i));
76 : 263325608 : SET_REG_N_REFS (i, DF_REG_USE_COUNT (i) + REG_N_SETS (i));
77 : : }
78 : 3439754 : timevar_pop (TV_REG_STATS);
79 : :
80 : 3439754 : }
81 : :
82 : :
83 : : /* Free the array that holds the REG_N_SETS and REG_N_REFS. */
84 : :
85 : : void
86 : 3439754 : regstat_free_n_sets_and_refs (void)
87 : : {
88 : 3439754 : gcc_assert (regstat_n_sets_and_refs);
89 : 3439754 : free (regstat_n_sets_and_refs);
90 : 3439754 : regstat_n_sets_and_refs = NULL;
91 : 3439754 : }
92 : :
93 : :
94 : : /*----------------------------------------------------------------------------
95 : : REGISTER INFORMATION
96 : :
97 : : Process REG_N_DEATHS, REG_N_CALLS_CROSSED, and REG_BASIC_BLOCK.
98 : :
99 : : ----------------------------------------------------------------------------*/
100 : :
101 : : static bitmap setjmp_crosses;
102 : : struct reg_info_t *reg_info_p;
103 : :
104 : : /* The number allocated elements of reg_info_p. */
105 : : size_t reg_info_p_size;
106 : :
107 : : /* Compute register info: lifetime, bb, and number of defs and uses
108 : : for basic block BB. LIVE is a scratch bitvector used here. */
109 : :
110 : : static void
111 : 26756348 : regstat_bb_compute_ri (basic_block bb, bitmap live)
112 : : {
113 : 26756348 : rtx_insn *insn;
114 : 26756348 : df_ref def, use;
115 : 26756348 : bitmap_iterator bi;
116 : 26756348 : unsigned int regno;
117 : :
118 : 26756348 : bitmap_copy (live, df_get_live_out (bb));
119 : :
120 : : /* Process the regs live at the end of the block. Mark them as
121 : : not local to any one basic block. */
122 : 382280000 : EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
123 : 355523652 : REG_BASIC_BLOCK (regno) = REG_BLOCK_GLOBAL;
124 : :
125 : : /* Process the artificial defs and uses at the bottom of the block
126 : : to begin processing. */
127 : 54383360 : FOR_EACH_ARTIFICIAL_DEF (def, bb->index)
128 : 870664 : if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
129 : 0 : bitmap_clear_bit (live, DF_REF_REGNO (def));
130 : :
131 : 160538088 : FOR_EACH_ARTIFICIAL_USE (use, bb->index)
132 : 107025392 : if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
133 : : {
134 : 107025392 : regno = DF_REF_REGNO (use);
135 : 107025392 : bitmap_set_bit (live, regno);
136 : : }
137 : :
138 : 322142608 : FOR_BB_INSNS_REVERSE (bb, insn)
139 : : {
140 : 295386260 : struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
141 : 295386260 : bitmap_iterator bi;
142 : 295386260 : rtx link;
143 : :
144 : 295386260 : if (!NONDEBUG_INSN_P (insn))
145 : 138724085 : continue;
146 : :
147 : 156662175 : link = REG_NOTES (insn);
148 : 324133932 : while (link)
149 : : {
150 : 167471757 : if (REG_NOTE_KIND (link) == REG_DEAD)
151 : 94149386 : REG_N_DEATHS (REGNO (XEXP (link, 0)))++;
152 : 167471757 : link = XEXP (link, 1);
153 : : }
154 : :
155 : : /* Process the defs. */
156 : 156662175 : if (CALL_P (insn))
157 : : {
158 : 11149029 : bool set_jump = (find_reg_note (insn, REG_SETJMP, NULL) != NULL);
159 : 196424360 : EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
160 : : {
161 : 185275331 : REG_N_CALLS_CROSSED (regno)++;
162 : :
163 : : /* We have a problem with any pseudoreg that lives
164 : : across the setjmp. ANSI says that if a user variable
165 : : does not change in value between the setjmp and the
166 : : longjmp, then the longjmp preserves it. This
167 : : includes longjmp from a place where the pseudo
168 : : appears dead. (In principle, the value still exists
169 : : if it is in scope.) If the pseudo goes in a hard
170 : : reg, some other value may occupy that hard reg where
171 : : this pseudo is dead, thus clobbering the pseudo.
172 : : Conclusion: such a pseudo must not go in a hard
173 : : reg. */
174 : 185275331 : if (set_jump)
175 : 10679 : bitmap_set_bit (setjmp_crosses, regno);
176 : : }
177 : : }
178 : :
179 : : /* All of the defs except the return value are some sort of
180 : : clobber. This code is for the return. */
181 : 1199995015 : FOR_EACH_INSN_INFO_DEF (def, insn_info)
182 : : {
183 : 1043332840 : if ((!CALL_P (insn))
184 : 914096964 : || (!(DF_REF_FLAGS (def)
185 : : & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))))
186 : : {
187 : 134460883 : unsigned int dregno = DF_REF_REGNO (def);
188 : :
189 : : /* Kill this register if it is not a subreg store or
190 : : conditional store.
191 : : ??? This means that any partial store is live from
192 : : the last use in a basic block to the start of this
193 : : basic block. */
194 : 134460883 : if (!(DF_REF_FLAGS (def)
195 : : & (DF_REF_PARTIAL | DF_REF_CONDITIONAL)))
196 : 133827581 : bitmap_clear_bit (live, dregno);
197 : :
198 : 134460883 : if (dregno >= FIRST_PSEUDO_REGISTER)
199 : : {
200 : 66512492 : REG_FREQ (dregno) += REG_FREQ_FROM_BB (bb);
201 : 66512492 : REG_FREQ (dregno) =
202 : 66512492 : MIN (REG_FREQ (dregno), REG_FREQ_MAX);
203 : :
204 : 66512492 : if (REG_BASIC_BLOCK (dregno) == REG_BLOCK_UNKNOWN)
205 : 1096292 : REG_BASIC_BLOCK (dregno) = bb->index;
206 : 65416200 : else if (REG_BASIC_BLOCK (dregno) != bb->index)
207 : 22828517 : REG_BASIC_BLOCK (dregno) = REG_BLOCK_GLOBAL;
208 : : }
209 : : }
210 : : }
211 : :
212 : 345836250 : FOR_EACH_INSN_INFO_USE (use, insn_info)
213 : : {
214 : 189174075 : unsigned int uregno = DF_REF_REGNO (use);
215 : :
216 : 189174075 : if (uregno >= FIRST_PSEUDO_REGISTER)
217 : : {
218 : 99177746 : REG_FREQ (uregno) += REG_FREQ_FROM_BB (bb);
219 : 99177746 : REG_FREQ (uregno) =
220 : 99177746 : MIN (REG_FREQ (uregno), REG_FREQ_MAX);
221 : :
222 : 99177746 : if (REG_BASIC_BLOCK (uregno) == REG_BLOCK_UNKNOWN)
223 : 41536706 : REG_BASIC_BLOCK (uregno) = bb->index;
224 : 57641040 : else if (REG_BASIC_BLOCK (uregno) != bb->index)
225 : 48708769 : REG_BASIC_BLOCK (uregno) = REG_BLOCK_GLOBAL;
226 : : }
227 : : }
228 : : }
229 : 26756348 : }
230 : :
231 : :
232 : : /* Compute register info: lifetime, bb, and number of defs and uses. */
233 : : void
234 : 2438245 : regstat_compute_ri (void)
235 : : {
236 : 2438245 : basic_block bb;
237 : 2438245 : bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);
238 : 2438245 : unsigned int regno;
239 : 2438245 : bitmap_iterator bi;
240 : :
241 : : /* Initialize everything. */
242 : :
243 : 2438245 : gcc_assert (!reg_info_p);
244 : :
245 : 2438245 : timevar_push (TV_REG_STATS);
246 : 2438245 : setjmp_crosses = BITMAP_ALLOC (&df_bitmap_obstack);
247 : 2438245 : max_regno = max_reg_num ();
248 : 2438245 : reg_info_p_size = max_regno;
249 : 2438245 : reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);
250 : :
251 : 29194593 : FOR_EACH_BB_FN (bb, cfun)
252 : : {
253 : 26756348 : regstat_bb_compute_ri (bb, live);
254 : : }
255 : :
256 : 2438245 : BITMAP_FREE (live);
257 : :
258 : : /* See the setjmp comment in regstat_bb_compute_ri. */
259 : 2439503 : EXECUTE_IF_SET_IN_BITMAP (setjmp_crosses, FIRST_PSEUDO_REGISTER, regno, bi)
260 : : {
261 : 1258 : REG_BASIC_BLOCK (regno) = REG_BLOCK_UNKNOWN;
262 : : }
263 : :
264 : 2438245 : timevar_pop (TV_REG_STATS);
265 : 2438245 : }
266 : :
267 : :
268 : : /* Free all storage associated with the problem. */
269 : :
270 : : void
271 : 2438245 : regstat_free_ri (void)
272 : : {
273 : 2438245 : gcc_assert (reg_info_p);
274 : 2438245 : reg_info_p_size = 0;
275 : 2438245 : free (reg_info_p);
276 : 2438245 : reg_info_p = NULL;
277 : :
278 : 2438245 : BITMAP_FREE (setjmp_crosses);
279 : 2438245 : }
280 : :
281 : :
282 : : /* Return a bitmap containing the set of registers that cross a setjmp.
283 : : The client should not change or delete this bitmap. */
284 : :
285 : : bitmap
286 : 1667400 : regstat_get_setjmp_crosses (void)
287 : : {
288 : 1667400 : return setjmp_crosses;
289 : : }
290 : :
291 : : /*----------------------------------------------------------------------------
292 : : Process REG_N_CALLS_CROSSED.
293 : :
294 : : This is used by sched_deps. A good implementation of sched-deps
295 : : would really process the blocks directly rather than going through
296 : : lists of insns. If it did this, it could use the exact regs that
297 : : cross an individual call rather than using this info that merges
298 : : the info for all calls.
299 : :
300 : : ----------------------------------------------------------------------------*/
301 : :
302 : :
303 : :
304 : : /* Compute calls crossed for BB. Live is a scratch bitvector. */
305 : :
306 : : static void
307 : 9131798 : regstat_bb_compute_calls_crossed (unsigned int bb_index, bitmap live)
308 : : {
309 : 9131798 : basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
310 : 9131798 : rtx_insn *insn;
311 : 9131798 : df_ref def, use;
312 : :
313 : 9131798 : bitmap_copy (live, df_get_live_out (bb));
314 : :
315 : : /* Process the artificial defs and uses at the bottom of the block
316 : : to begin processing. */
317 : 18600184 : FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
318 : 336588 : if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
319 : 0 : bitmap_clear_bit (live, DF_REF_REGNO (def));
320 : :
321 : 28728408 : FOR_EACH_ARTIFICIAL_USE (use, bb_index)
322 : 10464812 : if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
323 : 10464812 : bitmap_set_bit (live, DF_REF_REGNO (use));
324 : :
325 : 120228920 : FOR_BB_INSNS_REVERSE (bb, insn)
326 : : {
327 : 111097122 : if (!NONDEBUG_INSN_P (insn))
328 : 56327223 : continue;
329 : :
330 : 54769899 : gcc_assert (INSN_UID (insn) < (int) DF_INSN_SIZE ());
331 : 54769899 : struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
332 : 54769899 : unsigned int regno;
333 : :
334 : : /* Process the defs. */
335 : 54769899 : if (CALL_P (insn))
336 : : {
337 : 4146449 : bitmap_iterator bi;
338 : 18012581 : EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
339 : : {
340 : 13866132 : REG_N_CALLS_CROSSED (regno)++;
341 : : }
342 : : }
343 : :
344 : : /* All of the defs except the return value are some sort of
345 : : clobber. This code is for the return. */
346 : 436831136 : FOR_EACH_INSN_INFO_DEF (def, insn_info)
347 : : {
348 : 382061237 : if ((!CALL_P (insn))
349 : 337876748 : || (!(DF_REF_FLAGS (def) & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))))
350 : : {
351 : : /* Kill this register if it is not a subreg store or conditional store. */
352 : 46167343 : if (!(DF_REF_FLAGS (def) & (DF_REF_PARTIAL | DF_REF_CONDITIONAL)))
353 : 46123132 : bitmap_clear_bit (live, DF_REF_REGNO (def));
354 : : }
355 : : }
356 : :
357 : 123499081 : FOR_EACH_INSN_INFO_USE (use, insn_info)
358 : 68729182 : bitmap_set_bit (live, DF_REF_REGNO (use));
359 : : }
360 : 9131798 : }
361 : :
362 : :
363 : : /* Compute register info: lifetime, bb, and number of defs and uses. */
364 : : void
365 : 901359 : regstat_compute_calls_crossed (void)
366 : : {
367 : 901359 : basic_block bb;
368 : 901359 : bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);
369 : :
370 : : /* Initialize everything. */
371 : 901359 : gcc_assert (!reg_info_p);
372 : :
373 : 901359 : timevar_push (TV_REG_STATS);
374 : 901359 : max_regno = max_reg_num ();
375 : 901359 : reg_info_p_size = max_regno;
376 : 901359 : reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);
377 : :
378 : 10033157 : FOR_EACH_BB_FN (bb, cfun)
379 : : {
380 : 9131798 : regstat_bb_compute_calls_crossed (bb->index, live);
381 : : }
382 : :
383 : 901359 : BITMAP_FREE (live);
384 : 901359 : timevar_pop (TV_REG_STATS);
385 : 901359 : }
386 : :
387 : :
388 : : /* Free all storage associated with the problem. */
389 : :
390 : : void
391 : 901359 : regstat_free_calls_crossed (void)
392 : : {
393 : 901359 : gcc_assert (reg_info_p);
394 : 901359 : reg_info_p_size = 0;
395 : 901359 : free (reg_info_p);
396 : 901359 : reg_info_p = NULL;
397 : 901359 : }
398 : :
399 : : /* Dump the register info to FILE. */
400 : :
401 : : void
402 : 118 : dump_reg_info (FILE *file)
403 : : {
404 : 118 : unsigned int i, max = max_reg_num ();
405 : 118 : if (reload_completed)
406 : : return;
407 : :
408 : 85 : if (reg_info_p_size < max)
409 : 85 : max = reg_info_p_size;
410 : :
411 : 85 : fprintf (file, "%d registers.\n", max);
412 : 85 : for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
413 : : {
414 : 0 : enum reg_class rclass, altclass;
415 : :
416 : 0 : if (regstat_n_sets_and_refs)
417 : 0 : fprintf (file, "\nRegister %d used %d times",
418 : : i, REG_N_REFS (i));
419 : 0 : else if (df)
420 : 0 : fprintf (file, "\nRegister %d used %d times",
421 : 0 : i, DF_REG_USE_COUNT (i) + DF_REG_DEF_COUNT (i));
422 : :
423 : 0 : if (REG_BASIC_BLOCK (i) >= NUM_FIXED_BLOCKS)
424 : 0 : fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
425 : 0 : if (regstat_n_sets_and_refs)
426 : 0 : fprintf (file, "; set %d time%s", REG_N_SETS (i),
427 : 0 : (REG_N_SETS (i) == 1) ? "" : "s");
428 : 0 : else if (df)
429 : 0 : fprintf (file, "; set %d time%s", DF_REG_DEF_COUNT (i),
430 : 0 : (DF_REG_DEF_COUNT (i) == 1) ? "" : "s");
431 : 0 : if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
432 : 0 : fputs ("; user var", file);
433 : 0 : if (REG_N_DEATHS (i) != 1)
434 : 0 : fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
435 : 0 : if (REG_N_CALLS_CROSSED (i) == 1)
436 : 0 : fputs ("; crosses 1 call", file);
437 : 0 : else if (REG_N_CALLS_CROSSED (i))
438 : 0 : fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
439 : 0 : if (regno_reg_rtx[i] != NULL
440 : 0 : && maybe_ne (PSEUDO_REGNO_BYTES (i), UNITS_PER_WORD))
441 : : {
442 : 0 : fprintf (file, "; ");
443 : 0 : print_dec (PSEUDO_REGNO_BYTES (i), file, SIGNED);
444 : 0 : fprintf (file, " bytes");
445 : : }
446 : :
447 : 0 : rclass = reg_preferred_class (i);
448 : 0 : altclass = reg_alternate_class (i);
449 : 0 : if (rclass != GENERAL_REGS || altclass != ALL_REGS)
450 : : {
451 : 0 : if (altclass == ALL_REGS || rclass == ALL_REGS)
452 : 0 : fprintf (file, "; pref %s", reg_class_names[(int) rclass]);
453 : 0 : else if (altclass == NO_REGS)
454 : 0 : fprintf (file, "; %s or none", reg_class_names[(int) rclass]);
455 : : else
456 : 0 : fprintf (file, "; pref %s, else %s",
457 : 0 : reg_class_names[(int) rclass],
458 : 0 : reg_class_names[(int) altclass]);
459 : : }
460 : :
461 : 0 : if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
462 : 0 : fputs ("; pointer", file);
463 : 0 : fputs (".\n", file);
464 : : }
465 : : }
466 : :
|
