1/* Scanning of rtl for dataflow analysis.
2 Copyright (C) 2007-2017 Free Software Foundation, Inc.
3 Contributed by Kenneth Zadeck (zadeck@naturalbridge.com).
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along 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
32struct 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
45void
46regstat_init_n_sets_and_refs (void)
47{
48 unsigned int i;
49 unsigned int max_regno = max_reg_num ();
50
51 timevar_push (TV_REG_STATS);
52 df_grow_reg_info ();
53 gcc_assert (!regstat_n_sets_and_refs);
54
55 regstat_n_sets_and_refs = XNEWVEC (struct regstat_n_sets_and_refs_t, max_regno);
56
57 if (MAY_HAVE_DEBUG_BIND_INSNS)
58 for (i = 0; i < max_regno; i++)
59 {
60 int use_count;
61 df_ref use;
62
63 use_count = DF_REG_USE_COUNT (i);
64 for (use = DF_REG_USE_CHAIN (i); use; use = DF_REF_NEXT_REG (use))
65 if (DF_REF_INSN_INFO (use) && DEBUG_INSN_P (DF_REF_INSN (use)))
66 use_count--;
67
68
69 SET_REG_N_SETS (i, DF_REG_DEF_COUNT (i));
70 SET_REG_N_REFS (i, use_count + REG_N_SETS (i));
71 }
72 else
73 for (i = 0; i < max_regno; i++)
74 {
75 SET_REG_N_SETS (i, DF_REG_DEF_COUNT (i));
76 SET_REG_N_REFS (i, DF_REG_USE_COUNT (i) + REG_N_SETS (i));
77 }
78 timevar_pop (TV_REG_STATS);
79
80}
81
82
83/* Free the array that holds the REG_N_SETS and REG_N_REFS. */
84
85void
86regstat_free_n_sets_and_refs (void)
87{
88 gcc_assert (regstat_n_sets_and_refs);
89 free (regstat_n_sets_and_refs);
90 regstat_n_sets_and_refs = NULL;
91}
92
93
94/*----------------------------------------------------------------------------
95 REGISTER INFORMATION
96
97 Process REG_N_DEATHS, REG_N_CALLS_CROSSED, and REG_BASIC_BLOCK.
98
99 ----------------------------------------------------------------------------*/
100
101static bitmap setjmp_crosses;
102struct reg_info_t *reg_info_p;
103
104/* The number allocated elements of reg_info_p. */
105size_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
110static void
111regstat_bb_compute_ri (basic_block bb, bitmap live)
112{
113 rtx_insn *insn;
114 df_ref def, use;
115 bitmap_iterator bi;
116 unsigned int regno;
117
118 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 EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
123 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 FOR_EACH_ARTIFICIAL_DEF (def, bb->index)
128 if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
129 bitmap_clear_bit (live, DF_REF_REGNO (def));
130
131 FOR_EACH_ARTIFICIAL_USE (use, bb->index)
132 if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
133 {
134 regno = DF_REF_REGNO (use);
135 bitmap_set_bit (live, regno);
136 }
137
138 FOR_BB_INSNS_REVERSE (bb, insn)
139 {
140 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
141 bitmap_iterator bi;
142 rtx link;
143
144 if (!NONDEBUG_INSN_P (insn))
145 continue;
146
147 link = REG_NOTES (insn);
148 while (link)
149 {
150 if (REG_NOTE_KIND (link) == REG_DEAD)
151 REG_N_DEATHS (REGNO (XEXP (link, 0)))++;
152 link = XEXP (link, 1);
153 }
154
155 /* Process the defs. */
156 if (CALL_P (insn))
157 {
158 bool set_jump = (find_reg_note (insn, REG_SETJMP, NULL) != NULL);
159 EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
160 {
161 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 if (set_jump)
175 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 FOR_EACH_INSN_INFO_DEF (def, insn_info)
182 {
183 if ((!CALL_P (insn))
184 || (!(DF_REF_FLAGS (def)
185 & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))))
186 {
187 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 if (!(DF_REF_FLAGS (def)
195 & (DF_REF_PARTIAL | DF_REF_CONDITIONAL)))
196 bitmap_clear_bit (live, dregno);
197
198 if (dregno >= FIRST_PSEUDO_REGISTER)
199 {
200 REG_FREQ (dregno) += REG_FREQ_FROM_BB (bb);
201 REG_FREQ (dregno) =
202 MIN (REG_FREQ (dregno), REG_FREQ_MAX);
203
204 if (REG_BASIC_BLOCK (dregno) == REG_BLOCK_UNKNOWN)
205 REG_BASIC_BLOCK (dregno) = bb->index;
206 else if (REG_BASIC_BLOCK (dregno) != bb->index)
207 REG_BASIC_BLOCK (dregno) = REG_BLOCK_GLOBAL;
208 }
209 }
210 }
211
212 FOR_EACH_INSN_INFO_USE (use, insn_info)
213 {
214 unsigned int uregno = DF_REF_REGNO (use);
215
216 if (uregno >= FIRST_PSEUDO_REGISTER)
217 {
218 REG_FREQ (uregno) += REG_FREQ_FROM_BB (bb);
219 REG_FREQ (uregno) =
220 MIN (REG_FREQ (uregno), REG_FREQ_MAX);
221
222 if (REG_BASIC_BLOCK (uregno) == REG_BLOCK_UNKNOWN)
223 REG_BASIC_BLOCK (uregno) = bb->index;
224 else if (REG_BASIC_BLOCK (uregno) != bb->index)
225 REG_BASIC_BLOCK (uregno) = REG_BLOCK_GLOBAL;
226 }
227 }
228 }
229}
230
231
232/* Compute register info: lifetime, bb, and number of defs and uses. */
233void
234regstat_compute_ri (void)
235{
236 basic_block bb;
237 bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);
238 unsigned int regno;
239 bitmap_iterator bi;
240
241 /* Initialize everything. */
242
243 gcc_assert (!reg_info_p);
244
245 timevar_push (TV_REG_STATS);
246 setjmp_crosses = BITMAP_ALLOC (&df_bitmap_obstack);
247 max_regno = max_reg_num ();
248 reg_info_p_size = max_regno;
249 reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);
250
251 FOR_EACH_BB_FN (bb, cfun)
252 {
253 regstat_bb_compute_ri (bb, live);
254 }
255
256 BITMAP_FREE (live);
257
258 /* See the setjmp comment in regstat_bb_compute_ri. */
259 EXECUTE_IF_SET_IN_BITMAP (setjmp_crosses, FIRST_PSEUDO_REGISTER, regno, bi)
260 {
261 REG_BASIC_BLOCK (regno) = REG_BLOCK_UNKNOWN;
262 }
263
264 timevar_pop (TV_REG_STATS);
265}
266
267
268/* Free all storage associated with the problem. */
269
270void
271regstat_free_ri (void)
272{
273 gcc_assert (reg_info_p);
274 reg_info_p_size = 0;
275 free (reg_info_p);
276 reg_info_p = NULL;
277
278 BITMAP_FREE (setjmp_crosses);
279}
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
285bitmap
286regstat_get_setjmp_crosses (void)
287{
288 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
306static void
307regstat_bb_compute_calls_crossed (unsigned int bb_index, bitmap live)
308{
309 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
310 rtx_insn *insn;
311 df_ref def, use;
312
313 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 FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
318 if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
319 bitmap_clear_bit (live, DF_REF_REGNO (def));
320
321 FOR_EACH_ARTIFICIAL_USE (use, bb_index)
322 if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
323 bitmap_set_bit (live, DF_REF_REGNO (use));
324
325 FOR_BB_INSNS_REVERSE (bb, insn)
326 {
327 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
328 unsigned int regno;
329
330 if (!NONDEBUG_INSN_P (insn))
331 continue;
332
333 /* Process the defs. */
334 if (CALL_P (insn))
335 {
336 bitmap_iterator bi;
337 EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
338 {
339 REG_N_CALLS_CROSSED (regno)++;
340 }
341 }
342
343 /* All of the defs except the return value are some sort of
344 clobber. This code is for the return. */
345 FOR_EACH_INSN_INFO_DEF (def, insn_info)
346 {
347 if ((!CALL_P (insn))
348 || (!(DF_REF_FLAGS (def) & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))))
349 {
350 /* Kill this register if it is not a subreg store or conditional store. */
351 if (!(DF_REF_FLAGS (def) & (DF_REF_PARTIAL | DF_REF_CONDITIONAL)))
352 bitmap_clear_bit (live, DF_REF_REGNO (def));
353 }
354 }
355
356 FOR_EACH_INSN_INFO_USE (use, insn_info)
357 bitmap_set_bit (live, DF_REF_REGNO (use));
358 }
359}
360
361
362/* Compute register info: lifetime, bb, and number of defs and uses. */
363void
364regstat_compute_calls_crossed (void)
365{
366 basic_block bb;
367 bitmap live = BITMAP_ALLOC (&df_bitmap_obstack);
368
369 /* Initialize everything. */
370 gcc_assert (!reg_info_p);
371
372 timevar_push (TV_REG_STATS);
373 max_regno = max_reg_num ();
374 reg_info_p_size = max_regno;
375 reg_info_p = XCNEWVEC (struct reg_info_t, max_regno);
376
377 FOR_EACH_BB_FN (bb, cfun)
378 {
379 regstat_bb_compute_calls_crossed (bb->index, live);
380 }
381
382 BITMAP_FREE (live);
383 timevar_pop (TV_REG_STATS);
384}
385
386
387/* Free all storage associated with the problem. */
388
389void
390regstat_free_calls_crossed (void)
391{
392 gcc_assert (reg_info_p);
393 reg_info_p_size = 0;
394 free (reg_info_p);
395 reg_info_p = NULL;
396}
397
398/* Dump the register info to FILE. */
399
400void
401dump_reg_info (FILE *file)
402{
403 unsigned int i, max = max_reg_num ();
404 if (reload_completed)
405 return;
406
407 if (reg_info_p_size < max)
408 max = reg_info_p_size;
409
410 fprintf (file, "%d registers.\n", max);
411 for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
412 {
413 enum reg_class rclass, altclass;
414
415 if (regstat_n_sets_and_refs)
416 fprintf (file, "\nRegister %d used %d times",
417 i, REG_N_REFS (i));
418 else if (df)
419 fprintf (file, "\nRegister %d used %d times",
420 i, DF_REG_USE_COUNT (i) + DF_REG_DEF_COUNT (i));
421
422 if (REG_BASIC_BLOCK (i) >= NUM_FIXED_BLOCKS)
423 fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
424 if (regstat_n_sets_and_refs)
425 fprintf (file, "; set %d time%s", REG_N_SETS (i),
426 (REG_N_SETS (i) == 1) ? "" : "s");
427 else if (df)
428 fprintf (file, "; set %d time%s", DF_REG_DEF_COUNT (i),
429 (DF_REG_DEF_COUNT (i) == 1) ? "" : "s");
430 if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
431 fputs ("; user var", file);
432 if (REG_N_DEATHS (i) != 1)
433 fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
434 if (REG_N_CALLS_CROSSED (i) == 1)
435 fputs ("; crosses 1 call", file);
436 else if (REG_N_CALLS_CROSSED (i))
437 fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
438 if (regno_reg_rtx[i] != NULL
439 && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
440 fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
441
442 rclass = reg_preferred_class (i);
443 altclass = reg_alternate_class (i);
444 if (rclass != GENERAL_REGS || altclass != ALL_REGS)
445 {
446 if (altclass == ALL_REGS || rclass == ALL_REGS)
447 fprintf (file, "; pref %s", reg_class_names[(int) rclass]);
448 else if (altclass == NO_REGS)
449 fprintf (file, "; %s or none", reg_class_names[(int) rclass]);
450 else
451 fprintf (file, "; pref %s, else %s",
452 reg_class_names[(int) rclass],
453 reg_class_names[(int) altclass]);
454 }
455
456 if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
457 fputs ("; pointer", file);
458 fputs (".\n", file);
459 }
460}
461
462