?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2015-06-23 Richard Biener <rguenther@suse.de>
[official-gcc.git] / gcc / df-scan.c
blobef9cdbbbe32ca414fee3504626e3e83dc694fc0a
1 /* Scanning of rtl for dataflow analysis.
2 Copyright (C) 1999-2015 Free Software Foundation, Inc.
3 Originally contributed by Michael P. Hayes
4 (m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
5 Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
6 and Kenneth Zadeck (zadeck@naturalbridge.com).
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
13 version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "rtl.h"
29 #include "tm_p.h"
30 #include "insn-config.h"
31 #include "recog.h"
32 #include "alias.h"
33 #include "symtab.h"
34 #include "hard-reg-set.h"
35 #include "function.h"
36 #include "regs.h"
37 #include "alloc-pool.h"
38 #include "flags.h"
39 #include "predict.h"
40 #include "dominance.h"
41 #include "cfg.h"
42 #include "basic-block.h"
43 #include "sbitmap.h"
44 #include "bitmap.h"
45 #include "dumpfile.h"
46 #include "tree.h"
47 #include "target.h"
48 #include "target-def.h"
49 #include "df.h"
50 #include "emit-rtl.h" /* FIXME: Can go away once crtl is moved to rtl.h. */
51
52
53 typedef struct df_mw_hardreg *df_mw_hardreg_ptr;
54
55
56 #ifndef HAVE_prologue
57 #define HAVE_prologue 0
58 #endif
59 #ifndef HAVE_sibcall_epilogue
60 #define HAVE_sibcall_epilogue 0
61 #endif
62
63 /* The set of hard registers in eliminables[i].from. */
64
65 static HARD_REG_SET elim_reg_set;
66
67 /* Initialize ur_in and ur_out as if all hard registers were partially
68 available. */
69
70 struct df_collection_rec
71 {
72 auto_vec<df_ref, 128> def_vec;
73 auto_vec<df_ref, 32> use_vec;
74 auto_vec<df_ref, 32> eq_use_vec;
75 auto_vec<df_mw_hardreg_ptr, 32> mw_vec;
76 };
77
78 static void df_ref_record (enum df_ref_class, struct df_collection_rec *,
79 rtx, rtx *,
80 basic_block, struct df_insn_info *,
81 enum df_ref_type, int ref_flags);
82 static void df_def_record_1 (struct df_collection_rec *, rtx *,
83 basic_block, struct df_insn_info *,
84 int ref_flags);
85 static void df_defs_record (struct df_collection_rec *, rtx,
86 basic_block, struct df_insn_info *,
87 int ref_flags);
88 static void df_uses_record (struct df_collection_rec *,
89 rtx *, enum df_ref_type,
90 basic_block, struct df_insn_info *,
91 int ref_flags);
92
93 static void df_install_ref_incremental (df_ref);
94 static void df_insn_refs_collect (struct df_collection_rec*,
95 basic_block, struct df_insn_info *);
96 static void df_canonize_collection_rec (struct df_collection_rec *);
97
98 static void df_get_regular_block_artificial_uses (bitmap);
99 static void df_get_eh_block_artificial_uses (bitmap);
100
101 static void df_record_entry_block_defs (bitmap);
102 static void df_record_exit_block_uses (bitmap);
103 static void df_get_exit_block_use_set (bitmap);
104 static void df_get_entry_block_def_set (bitmap);
105 static void df_grow_ref_info (struct df_ref_info *, unsigned int);
106 static void df_ref_chain_delete_du_chain (df_ref);
107 static void df_ref_chain_delete (df_ref);
108
109 static void df_refs_add_to_chains (struct df_collection_rec *,
110 basic_block, rtx_insn *, unsigned int);
111
112 static bool df_insn_refs_verify (struct df_collection_rec *, basic_block,
113 rtx_insn *, bool);
114 static void df_entry_block_defs_collect (struct df_collection_rec *, bitmap);
115 static void df_exit_block_uses_collect (struct df_collection_rec *, bitmap);
116 static void df_install_ref (df_ref, struct df_reg_info *,
117 struct df_ref_info *, bool);
118
119 static int df_ref_compare (df_ref, df_ref);
120 static int df_ref_ptr_compare (const void *, const void *);
121 static int df_mw_compare (const df_mw_hardreg *, const df_mw_hardreg *);
122 static int df_mw_ptr_compare (const void *, const void *);
123
124 static void df_insn_info_delete (unsigned int);
125
126 /* Indexed by hardware reg number, is true if that register is ever
127 used in the current function.
128
129 In df-scan.c, this is set up to record the hard regs used
130 explicitly. Reload adds in the hard regs used for holding pseudo
131 regs. Final uses it to generate the code in the function prologue
132 and epilogue to save and restore registers as needed. */
133
134 static bool regs_ever_live[FIRST_PSEUDO_REGISTER];
135
136 /* Flags used to tell df_refs_add_to_chains() which vectors it should copy. */
137 static const unsigned int copy_defs = 0x1;
138 static const unsigned int copy_uses = 0x2;
139 static const unsigned int copy_eq_uses = 0x4;
140 static const unsigned int copy_mw = 0x8;
141 static const unsigned int copy_all = copy_defs | copy_uses | copy_eq_uses
142 | copy_mw;
143 \f
144 /*----------------------------------------------------------------------------
145 SCANNING DATAFLOW PROBLEM
146
147 There are several ways in which scanning looks just like the other
148 dataflow problems. It shares the all the mechanisms for local info
149 as well as basic block info. Where it differs is when and how often
150 it gets run. It also has no need for the iterative solver.
151 ----------------------------------------------------------------------------*/
152
153 #define SCAN_PROBLEM_DATA_BLOCK_SIZE 512
154
155 /* Problem data for the scanning dataflow function. */
156 struct df_scan_problem_data
157 {
158 pool_allocator<df_base_ref> *ref_base_pool;
159 pool_allocator<df_artificial_ref> *ref_artificial_pool;
160 pool_allocator<df_regular_ref> *ref_regular_pool;
161 pool_allocator<df_insn_info> *insn_pool;
162 pool_allocator<df_reg_info> *reg_pool;
163 pool_allocator<df_mw_hardreg> *mw_reg_pool;
164
165 bitmap_obstack reg_bitmaps;
166 bitmap_obstack insn_bitmaps;
167 };
168
169 typedef struct df_scan_bb_info *df_scan_bb_info_t;
170
171
172 /* Internal function to shut down the scanning problem. */
173 static void
174 df_scan_free_internal (void)
175 {
176 struct df_scan_problem_data *problem_data
177 = (struct df_scan_problem_data *) df_scan->problem_data;
178
179 free (df->def_info.refs);
180 free (df->def_info.begin);
181 free (df->def_info.count);
182 memset (&df->def_info, 0, (sizeof (struct df_ref_info)));
183
184 free (df->use_info.refs);
185 free (df->use_info.begin);
186 free (df->use_info.count);
187 memset (&df->use_info, 0, (sizeof (struct df_ref_info)));
188
189 free (df->def_regs);
190 df->def_regs = NULL;
191 free (df->use_regs);
192 df->use_regs = NULL;
193 free (df->eq_use_regs);
194 df->eq_use_regs = NULL;
195 df->regs_size = 0;
196 DF_REG_SIZE (df) = 0;
197
198 free (df->insns);
199 df->insns = NULL;
200 DF_INSN_SIZE () = 0;
201
202 free (df_scan->block_info);
203 df_scan->block_info = NULL;
204 df_scan->block_info_size = 0;
205
206 bitmap_clear (&df->hardware_regs_used);
207 bitmap_clear (&df->regular_block_artificial_uses);
208 bitmap_clear (&df->eh_block_artificial_uses);
209 BITMAP_FREE (df->entry_block_defs);
210 BITMAP_FREE (df->exit_block_uses);
211 bitmap_clear (&df->insns_to_delete);
212 bitmap_clear (&df->insns_to_rescan);
213 bitmap_clear (&df->insns_to_notes_rescan);
214
215 delete problem_data->ref_base_pool;
216 delete problem_data->ref_artificial_pool;
217 delete problem_data->ref_regular_pool;
218 delete problem_data->insn_pool;
219 delete problem_data->reg_pool;
220 delete problem_data->mw_reg_pool;
221 bitmap_obstack_release (&problem_data->reg_bitmaps);
222 bitmap_obstack_release (&problem_data->insn_bitmaps);
223 free (df_scan->problem_data);
224 }
225
226
227 /* Free basic block info. */
228
229 static void
230 df_scan_free_bb_info (basic_block bb, void *vbb_info)
231 {
232 struct df_scan_bb_info *bb_info = (struct df_scan_bb_info *) vbb_info;
233 unsigned int bb_index = bb->index;
234 rtx_insn *insn;
235
236 FOR_BB_INSNS (bb, insn)
237 if (INSN_P (insn))
238 df_insn_info_delete (INSN_UID (insn));
239
240 if (bb_index < df_scan->block_info_size)
241 bb_info = df_scan_get_bb_info (bb_index);
242
243 /* Get rid of any artificial uses or defs. */
244 df_ref_chain_delete_du_chain (bb_info->artificial_defs);
245 df_ref_chain_delete_du_chain (bb_info->artificial_uses);
246 df_ref_chain_delete (bb_info->artificial_defs);
247 df_ref_chain_delete (bb_info->artificial_uses);
248 bb_info->artificial_defs = NULL;
249 bb_info->artificial_uses = NULL;
250 }
251
252
253 /* Allocate the problem data for the scanning problem. This should be
254 called when the problem is created or when the entire function is to
255 be rescanned. */
256 void
257 df_scan_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
258 {
259 struct df_scan_problem_data *problem_data;
260 unsigned int insn_num = get_max_uid () + 1;
261 basic_block bb;
262
263 /* Given the number of pools, this is really faster than tearing
264 everything apart. */
265 if (df_scan->problem_data)
266 df_scan_free_internal ();
267
268 problem_data = XNEW (struct df_scan_problem_data);
269 df_scan->problem_data = problem_data;
270 df_scan->computed = true;
271
272 problem_data->ref_base_pool = new pool_allocator<df_base_ref>
273 ("df_scan ref base", SCAN_PROBLEM_DATA_BLOCK_SIZE);
274 problem_data->ref_artificial_pool = new pool_allocator<df_artificial_ref>
275 ("df_scan ref artificial", SCAN_PROBLEM_DATA_BLOCK_SIZE);
276 problem_data->ref_regular_pool = new pool_allocator<df_regular_ref>
277 ("df_scan ref regular", SCAN_PROBLEM_DATA_BLOCK_SIZE);
278 problem_data->insn_pool = new pool_allocator<df_insn_info>
279 ("df_scan insn", SCAN_PROBLEM_DATA_BLOCK_SIZE);
280 problem_data->reg_pool = new pool_allocator<df_reg_info>
281 ("df_scan reg", SCAN_PROBLEM_DATA_BLOCK_SIZE);
282 problem_data->mw_reg_pool = new pool_allocator<df_mw_hardreg>
283 ("df_scan mw_reg", SCAN_PROBLEM_DATA_BLOCK_SIZE / 16);
284
285 bitmap_obstack_initialize (&problem_data->reg_bitmaps);
286 bitmap_obstack_initialize (&problem_data->insn_bitmaps);
287
288 insn_num += insn_num / 4;
289 df_grow_reg_info ();
290
291 df_grow_insn_info ();
292 df_grow_bb_info (df_scan);
293
294 FOR_ALL_BB_FN (bb, cfun)
295 {
296 unsigned int bb_index = bb->index;
297 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb_index);
298 bb_info->artificial_defs = NULL;
299 bb_info->artificial_uses = NULL;
300 }
301
302 bitmap_initialize (&df->hardware_regs_used, &problem_data->reg_bitmaps);
303 bitmap_initialize (&df->regular_block_artificial_uses, &problem_data->reg_bitmaps);
304 bitmap_initialize (&df->eh_block_artificial_uses, &problem_data->reg_bitmaps);
305 df->entry_block_defs = BITMAP_ALLOC (&problem_data->reg_bitmaps);
306 df->exit_block_uses = BITMAP_ALLOC (&problem_data->reg_bitmaps);
307 bitmap_initialize (&df->insns_to_delete, &problem_data->insn_bitmaps);
308 bitmap_initialize (&df->insns_to_rescan, &problem_data->insn_bitmaps);
309 bitmap_initialize (&df->insns_to_notes_rescan, &problem_data->insn_bitmaps);
310 df_scan->optional_p = false;
311 }
312
313
314 /* Free all of the data associated with the scan problem. */
315
316 static void
317 df_scan_free (void)
318 {
319 if (df_scan->problem_data)
320 df_scan_free_internal ();
321
322 if (df->blocks_to_analyze)
323 {
324 BITMAP_FREE (df->blocks_to_analyze);
325 df->blocks_to_analyze = NULL;
326 }
327
328 free (df_scan);
329 }
330
331 /* Dump the preamble for DF_SCAN dump. */
332 static void
333 df_scan_start_dump (FILE *file ATTRIBUTE_UNUSED)
334 {
335 int i;
336 int dcount = 0;
337 int ucount = 0;
338 int ecount = 0;
339 int icount = 0;
340 int ccount = 0;
341 basic_block bb;
342 rtx_insn *insn;
343
344 fprintf (file, ";; invalidated by call \t");
345 df_print_regset (file, regs_invalidated_by_call_regset);
346 fprintf (file, ";; hardware regs used \t");
347 df_print_regset (file, &df->hardware_regs_used);
348 fprintf (file, ";; regular block artificial uses \t");
349 df_print_regset (file, &df->regular_block_artificial_uses);
350 fprintf (file, ";; eh block artificial uses \t");
351 df_print_regset (file, &df->eh_block_artificial_uses);
352 fprintf (file, ";; entry block defs \t");
353 df_print_regset (file, df->entry_block_defs);
354 fprintf (file, ";; exit block uses \t");
355 df_print_regset (file, df->exit_block_uses);
356 fprintf (file, ";; regs ever live \t");
357 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
358 if (df_regs_ever_live_p (i))
359 fprintf (file, " %d [%s]", i, reg_names[i]);
360 fprintf (file, "\n;; ref usage \t");
361
362 for (i = 0; i < (int)df->regs_inited; i++)
363 if (DF_REG_DEF_COUNT (i) || DF_REG_USE_COUNT (i) || DF_REG_EQ_USE_COUNT (i))
364 {
365 const char * sep = "";
366
367 fprintf (file, "r%d={", i);
368 if (DF_REG_DEF_COUNT (i))
369 {
370 fprintf (file, "%dd", DF_REG_DEF_COUNT (i));
371 sep = ",";
372 dcount += DF_REG_DEF_COUNT (i);
373 }
374 if (DF_REG_USE_COUNT (i))
375 {
376 fprintf (file, "%s%du", sep, DF_REG_USE_COUNT (i));
377 sep = ",";
378 ucount += DF_REG_USE_COUNT (i);
379 }
380 if (DF_REG_EQ_USE_COUNT (i))
381 {
382 fprintf (file, "%s%de", sep, DF_REG_EQ_USE_COUNT (i));
383 ecount += DF_REG_EQ_USE_COUNT (i);
384 }
385 fprintf (file, "} ");
386 }
387
388 FOR_EACH_BB_FN (bb, cfun)
389 FOR_BB_INSNS (bb, insn)
390 if (INSN_P (insn))
391 {
392 if (CALL_P (insn))
393 ccount++;
394 else
395 icount++;
396 }
397
398 fprintf (file, "\n;; total ref usage %d{%dd,%du,%de}"
399 " in %d{%d regular + %d call} insns.\n",
400 dcount + ucount + ecount, dcount, ucount, ecount,
401 icount + ccount, icount, ccount);
402 }
403
404 /* Dump the bb_info for a given basic block. */
405 static void
406 df_scan_start_block (basic_block bb, FILE *file)
407 {
408 struct df_scan_bb_info *bb_info
409 = df_scan_get_bb_info (bb->index);
410
411 if (bb_info)
412 {
413 fprintf (file, ";; bb %d artificial_defs: ", bb->index);
414 df_refs_chain_dump (bb_info->artificial_defs, true, file);
415 fprintf (file, "\n;; bb %d artificial_uses: ", bb->index);
416 df_refs_chain_dump (bb_info->artificial_uses, true, file);
417 fprintf (file, "\n");
418 }
419 #if 0
420 {
421 rtx_insn *insn;
422 FOR_BB_INSNS (bb, insn)
423 if (INSN_P (insn))
424 df_insn_debug (insn, false, file);
425 }
426 #endif
427 }
428
429 static struct df_problem problem_SCAN =
430 {
431 DF_SCAN, /* Problem id. */
432 DF_NONE, /* Direction. */
433 df_scan_alloc, /* Allocate the problem specific data. */
434 NULL, /* Reset global information. */
435 df_scan_free_bb_info, /* Free basic block info. */
436 NULL, /* Local compute function. */
437 NULL, /* Init the solution specific data. */
438 NULL, /* Iterative solver. */
439 NULL, /* Confluence operator 0. */
440 NULL, /* Confluence operator n. */
441 NULL, /* Transfer function. */
442 NULL, /* Finalize function. */
443 df_scan_free, /* Free all of the problem information. */
444 NULL, /* Remove this problem from the stack of dataflow problems. */
445 df_scan_start_dump, /* Debugging. */
446 df_scan_start_block, /* Debugging start block. */
447 NULL, /* Debugging end block. */
448 NULL, /* Debugging start insn. */
449 NULL, /* Debugging end insn. */
450 NULL, /* Incremental solution verify start. */
451 NULL, /* Incremental solution verify end. */
452 NULL, /* Dependent problem. */
453 sizeof (struct df_scan_bb_info),/* Size of entry of block_info array. */
454 TV_DF_SCAN, /* Timing variable. */
455 false /* Reset blocks on dropping out of blocks_to_analyze. */
456 };
457
458
459 /* Create a new DATAFLOW instance and add it to an existing instance
460 of DF. The returned structure is what is used to get at the
461 solution. */
462
463 void
464 df_scan_add_problem (void)
465 {
466 df_add_problem (&problem_SCAN);
467 }
468
469 \f
470 /*----------------------------------------------------------------------------
471 Storage Allocation Utilities
472 ----------------------------------------------------------------------------*/
473
474
475 /* First, grow the reg_info information. If the current size is less than
476 the number of pseudos, grow to 25% more than the number of
477 pseudos.
478
479 Second, assure that all of the slots up to max_reg_num have been
480 filled with reg_info structures. */
481
482 void
483 df_grow_reg_info (void)
484 {
485 unsigned int max_reg = max_reg_num ();
486 unsigned int new_size = max_reg;
487 struct df_scan_problem_data *problem_data
488 = (struct df_scan_problem_data *) df_scan->problem_data;
489 unsigned int i;
490
491 if (df->regs_size < new_size)
492 {
493 new_size += new_size / 4;
494 df->def_regs = XRESIZEVEC (struct df_reg_info *, df->def_regs, new_size);
495 df->use_regs = XRESIZEVEC (struct df_reg_info *, df->use_regs, new_size);
496 df->eq_use_regs = XRESIZEVEC (struct df_reg_info *, df->eq_use_regs,
497 new_size);
498 df->def_info.begin = XRESIZEVEC (unsigned, df->def_info.begin, new_size);
499 df->def_info.count = XRESIZEVEC (unsigned, df->def_info.count, new_size);
500 df->use_info.begin = XRESIZEVEC (unsigned, df->use_info.begin, new_size);
501 df->use_info.count = XRESIZEVEC (unsigned, df->use_info.count, new_size);
502 df->regs_size = new_size;
503 }
504
505 for (i = df->regs_inited; i < max_reg; i++)
506 {
507 struct df_reg_info *reg_info;
508
509 // TODO
510 reg_info = problem_data->reg_pool->allocate ();
511 memset (reg_info, 0, sizeof (struct df_reg_info));
512 df->def_regs[i] = reg_info;
513 reg_info = problem_data->reg_pool->allocate ();
514 memset (reg_info, 0, sizeof (struct df_reg_info));
515 df->use_regs[i] = reg_info;
516 reg_info = problem_data->reg_pool->allocate ();
517 memset (reg_info, 0, sizeof (struct df_reg_info));
518 df->eq_use_regs[i] = reg_info;
519 df->def_info.begin[i] = 0;
520 df->def_info.count[i] = 0;
521 df->use_info.begin[i] = 0;
522 df->use_info.count[i] = 0;
523 }
524
525 df->regs_inited = max_reg;
526 }
527
528
529 /* Grow the ref information. */
530
531 static void
532 df_grow_ref_info (struct df_ref_info *ref_info, unsigned int new_size)
533 {
534 if (ref_info->refs_size < new_size)
535 {
536 ref_info->refs = XRESIZEVEC (df_ref, ref_info->refs, new_size);
537 memset (ref_info->refs + ref_info->refs_size, 0,
538 (new_size - ref_info->refs_size) *sizeof (df_ref));
539 ref_info->refs_size = new_size;
540 }
541 }
542
543
544 /* Check and grow the ref information if necessary. This routine
545 guarantees total_size + BITMAP_ADDEND amount of entries in refs
546 array. It updates ref_info->refs_size only and does not change
547 ref_info->total_size. */
548
549 static void
550 df_check_and_grow_ref_info (struct df_ref_info *ref_info,
551 unsigned bitmap_addend)
552 {
553 if (ref_info->refs_size < ref_info->total_size + bitmap_addend)
554 {
555 int new_size = ref_info->total_size + bitmap_addend;
556 new_size += ref_info->total_size / 4;
557 df_grow_ref_info (ref_info, new_size);
558 }
559 }
560
561
562 /* Grow the ref information. If the current size is less than the
563 number of instructions, grow to 25% more than the number of
564 instructions. */
565
566 void
567 df_grow_insn_info (void)
568 {
569 unsigned int new_size = get_max_uid () + 1;
570 if (DF_INSN_SIZE () < new_size)
571 {
572 new_size += new_size / 4;
573 df->insns = XRESIZEVEC (struct df_insn_info *, df->insns, new_size);
574 memset (df->insns + df->insns_size, 0,
575 (new_size - DF_INSN_SIZE ()) *sizeof (struct df_insn_info *));
576 DF_INSN_SIZE () = new_size;
577 }
578 }
579
580
581
582 \f
583 /*----------------------------------------------------------------------------
584 PUBLIC INTERFACES FOR SMALL GRAIN CHANGES TO SCANNING.
585 ----------------------------------------------------------------------------*/
586
587 /* Rescan all of the block_to_analyze or all of the blocks in the
588 function if df_set_blocks if blocks_to_analyze is NULL; */
589
590 void
591 df_scan_blocks (void)
592 {
593 basic_block bb;
594
595 df->def_info.ref_order = DF_REF_ORDER_NO_TABLE;
596 df->use_info.ref_order = DF_REF_ORDER_NO_TABLE;
597
598 df_get_regular_block_artificial_uses (&df->regular_block_artificial_uses);
599 df_get_eh_block_artificial_uses (&df->eh_block_artificial_uses);
600
601 bitmap_ior_into (&df->eh_block_artificial_uses,
602 &df->regular_block_artificial_uses);
603
604 /* ENTRY and EXIT blocks have special defs/uses. */
605 df_get_entry_block_def_set (df->entry_block_defs);
606 df_record_entry_block_defs (df->entry_block_defs);
607 df_get_exit_block_use_set (df->exit_block_uses);
608 df_record_exit_block_uses (df->exit_block_uses);
609 df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK));
610 df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK));
611
612 /* Regular blocks */
613 FOR_EACH_BB_FN (bb, cfun)
614 {
615 unsigned int bb_index = bb->index;
616 df_bb_refs_record (bb_index, true);
617 }
618 }
619
620 /* Create new refs under address LOC within INSN. This function is
621 only used externally. REF_FLAGS must be either 0 or DF_REF_IN_NOTE,
622 depending on whether LOC is inside PATTERN (INSN) or a note. */
623
624 void
625 df_uses_create (rtx *loc, rtx_insn *insn, int ref_flags)
626 {
627 gcc_assert (!(ref_flags & ~DF_REF_IN_NOTE));
628 df_uses_record (NULL, loc, DF_REF_REG_USE,
629 BLOCK_FOR_INSN (insn),
630 DF_INSN_INFO_GET (insn),
631 ref_flags);
632 }
633
634 static void
635 df_install_ref_incremental (df_ref ref)
636 {
637 struct df_reg_info **reg_info;
638 struct df_ref_info *ref_info;
639 df_ref *ref_ptr;
640 bool add_to_table;
641
642 rtx_insn *insn = DF_REF_INSN (ref);
643 basic_block bb = BLOCK_FOR_INSN (insn);
644
645 if (DF_REF_REG_DEF_P (ref))
646 {
647 reg_info = df->def_regs;
648 ref_info = &df->def_info;
649 ref_ptr = &DF_INSN_DEFS (insn);
650 add_to_table = ref_info->ref_order != DF_REF_ORDER_NO_TABLE;
651 }
652 else if (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE)
653 {
654 reg_info = df->eq_use_regs;
655 ref_info = &df->use_info;
656 ref_ptr = &DF_INSN_EQ_USES (insn);
657 switch (ref_info->ref_order)
658 {
659 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
660 case DF_REF_ORDER_BY_REG_WITH_NOTES:
661 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
662 add_to_table = true;
663 break;
664 default:
665 add_to_table = false;
666 break;
667 }
668 }
669 else
670 {
671 reg_info = df->use_regs;
672 ref_info = &df->use_info;
673 ref_ptr = &DF_INSN_USES (insn);
674 add_to_table = ref_info->ref_order != DF_REF_ORDER_NO_TABLE;
675 }
676
677 /* Do not add if ref is not in the right blocks. */
678 if (add_to_table && df->analyze_subset)
679 add_to_table = bitmap_bit_p (df->blocks_to_analyze, bb->index);
680
681 df_install_ref (ref, reg_info[DF_REF_REGNO (ref)], ref_info, add_to_table);
682
683 if (add_to_table)
684 switch (ref_info->ref_order)
685 {
686 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
687 case DF_REF_ORDER_BY_REG_WITH_NOTES:
688 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
689 ref_info->ref_order = DF_REF_ORDER_UNORDERED_WITH_NOTES;
690 break;
691 default:
692 ref_info->ref_order = DF_REF_ORDER_UNORDERED;
693 break;
694 }
695
696 while (*ref_ptr && df_ref_compare (*ref_ptr, ref) < 0)
697 ref_ptr = &DF_REF_NEXT_LOC (*ref_ptr);
698
699 DF_REF_NEXT_LOC (ref) = *ref_ptr;
700 *ref_ptr = ref;
701
702 #if 0
703 if (dump_file)
704 {
705 fprintf (dump_file, "adding ref ");
706 df_ref_debug (ref, dump_file);
707 }
708 #endif
709 /* By adding the ref directly, df_insn_rescan my not find any
710 differences even though the block will have changed. So we need
711 to mark the block dirty ourselves. */
712 if (!DEBUG_INSN_P (DF_REF_INSN (ref)))
713 df_set_bb_dirty (bb);
714 }
715
716
717 \f
718 /*----------------------------------------------------------------------------
719 UTILITIES TO CREATE AND DESTROY REFS AND CHAINS.
720 ----------------------------------------------------------------------------*/
721
722 static void
723 df_free_ref (df_ref ref)
724 {
725 struct df_scan_problem_data *problem_data
726 = (struct df_scan_problem_data *) df_scan->problem_data;
727
728 switch (DF_REF_CLASS (ref))
729 {
730 case DF_REF_BASE:
731 problem_data->ref_base_pool->remove ((df_base_ref *) (ref));
732 break;
733
734 case DF_REF_ARTIFICIAL:
735 problem_data->ref_artificial_pool->remove
736 ((df_artificial_ref *) (ref));
737 break;
738
739 case DF_REF_REGULAR:
740 problem_data->ref_regular_pool->remove
741 ((df_regular_ref *) (ref));
742 break;
743 }
744 }
745
746
747 /* Unlink and delete REF at the reg_use, reg_eq_use or reg_def chain.
748 Also delete the def-use or use-def chain if it exists. */
749
750 static void
751 df_reg_chain_unlink (df_ref ref)
752 {
753 df_ref next = DF_REF_NEXT_REG (ref);
754 df_ref prev = DF_REF_PREV_REG (ref);
755 int id = DF_REF_ID (ref);
756 struct df_reg_info *reg_info;
757 df_ref *refs = NULL;
758
759 if (DF_REF_REG_DEF_P (ref))
760 {
761 int regno = DF_REF_REGNO (ref);
762 reg_info = DF_REG_DEF_GET (regno);
763 refs = df->def_info.refs;
764 }
765 else
766 {
767 if (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE)
768 {
769 reg_info = DF_REG_EQ_USE_GET (DF_REF_REGNO (ref));
770 switch (df->use_info.ref_order)
771 {
772 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
773 case DF_REF_ORDER_BY_REG_WITH_NOTES:
774 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
775 refs = df->use_info.refs;
776 break;
777 default:
778 break;
779 }
780 }
781 else
782 {
783 reg_info = DF_REG_USE_GET (DF_REF_REGNO (ref));
784 refs = df->use_info.refs;
785 }
786 }
787
788 if (refs)
789 {
790 if (df->analyze_subset)
791 {
792 if (bitmap_bit_p (df->blocks_to_analyze, DF_REF_BBNO (ref)))
793 refs[id] = NULL;
794 }
795 else
796 refs[id] = NULL;
797 }
798
799 /* Delete any def-use or use-def chains that start here. It is
800 possible that there is trash in this field. This happens for
801 insns that have been deleted when rescanning has been deferred
802 and the chain problem has also been deleted. The chain tear down
803 code skips deleted insns. */
804 if (df_chain && DF_REF_CHAIN (ref))
805 df_chain_unlink (ref);
806
807 reg_info->n_refs--;
808 if (DF_REF_FLAGS_IS_SET (ref, DF_HARD_REG_LIVE))
809 {
810 gcc_assert (DF_REF_REGNO (ref) < FIRST_PSEUDO_REGISTER);
811 df->hard_regs_live_count[DF_REF_REGNO (ref)]--;
812 }
813
814 /* Unlink from the reg chain. If there is no prev, this is the
815 first of the list. If not, just join the next and prev. */
816 if (prev)
817 DF_REF_NEXT_REG (prev) = next;
818 else
819 {
820 gcc_assert (reg_info->reg_chain == ref);
821 reg_info->reg_chain = next;
822 }
823 if (next)
824 DF_REF_PREV_REG (next) = prev;
825
826 df_free_ref (ref);
827 }
828
829
830 /* Create the insn record for INSN. If there was one there, zero it
831 out. */
832
833 struct df_insn_info *
834 df_insn_create_insn_record (rtx_insn *insn)
835 {
836 struct df_scan_problem_data *problem_data
837 = (struct df_scan_problem_data *) df_scan->problem_data;
838 struct df_insn_info *insn_rec;
839
840 df_grow_insn_info ();
841 insn_rec = DF_INSN_INFO_GET (insn);
842 if (!insn_rec)
843 {
844 insn_rec = problem_data->insn_pool->allocate ();
845 DF_INSN_INFO_SET (insn, insn_rec);
846 }
847 memset (insn_rec, 0, sizeof (struct df_insn_info));
848 insn_rec->insn = insn;
849 return insn_rec;
850 }
851
852
853 /* Delete all du chain (DF_REF_CHAIN()) of all refs in the ref chain. */
854
855 static void
856 df_ref_chain_delete_du_chain (df_ref ref)
857 {
858 for (; ref; ref = DF_REF_NEXT_LOC (ref))
859 /* CHAIN is allocated by DF_CHAIN. So make sure to
860 pass df_scan instance for the problem. */
861 if (DF_REF_CHAIN (ref))
862 df_chain_unlink (ref);
863 }
864
865
866 /* Delete all refs in the ref chain. */
867
868 static void
869 df_ref_chain_delete (df_ref ref)
870 {
871 df_ref next;
872 for (; ref; ref = next)
873 {
874 next = DF_REF_NEXT_LOC (ref);
875 df_reg_chain_unlink (ref);
876 }
877 }
878
879
880 /* Delete the hardreg chain. */
881
882 static void
883 df_mw_hardreg_chain_delete (struct df_mw_hardreg *hardregs)
884 {
885 struct df_scan_problem_data *problem_data
886 = (struct df_scan_problem_data *) df_scan->problem_data;
887 df_mw_hardreg *next;
888
889 for (; hardregs; hardregs = next)
890 {
891 next = DF_MWS_NEXT (hardregs);
892 problem_data->mw_reg_pool->remove (hardregs);
893 }
894 }
895
896
897 /* Delete all of the refs information from the insn with UID.
898 Internal helper for df_insn_delete, df_insn_rescan, and other
899 df-scan routines that don't have to work in deferred mode
900 and do not have to mark basic blocks for re-processing. */
901
902 static void
903 df_insn_info_delete (unsigned int uid)
904 {
905 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
906
907 bitmap_clear_bit (&df->insns_to_delete, uid);
908 bitmap_clear_bit (&df->insns_to_rescan, uid);
909 bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
910 if (insn_info)
911 {
912 struct df_scan_problem_data *problem_data
913 = (struct df_scan_problem_data *) df_scan->problem_data;
914
915 /* In general, notes do not have the insn_info fields
916 initialized. However, combine deletes insns by changing them
917 to notes. How clever. So we cannot just check if it is a
918 valid insn before short circuiting this code, we need to see
919 if we actually initialized it. */
920 df_mw_hardreg_chain_delete (insn_info->mw_hardregs);
921
922 if (df_chain)
923 {
924 df_ref_chain_delete_du_chain (insn_info->defs);
925 df_ref_chain_delete_du_chain (insn_info->uses);
926 df_ref_chain_delete_du_chain (insn_info->eq_uses);
927 }
928
929 df_ref_chain_delete (insn_info->defs);
930 df_ref_chain_delete (insn_info->uses);
931 df_ref_chain_delete (insn_info->eq_uses);
932
933 problem_data->insn_pool->remove (insn_info);
934 DF_INSN_UID_SET (uid, NULL);
935 }
936 }
937
938 /* Delete all of the refs information from INSN, either right now
939 or marked for later in deferred mode. */
940
941 void
942 df_insn_delete (rtx_insn *insn)
943 {
944 unsigned int uid;
945 basic_block bb;
946
947 gcc_checking_assert (INSN_P (insn));
948
949 if (!df)
950 return;
951
952 uid = INSN_UID (insn);
953 bb = BLOCK_FOR_INSN (insn);
954
955 /* ??? bb can be NULL after pass_free_cfg. At that point, DF should
956 not exist anymore (as mentioned in df-core.c: "The only requirement
957 [for DF] is that there be a correct control flow graph." Clearly
958 that isn't the case after pass_free_cfg. But DF is freed much later
959 because some back-ends want to use DF info even though the CFG is
960 already gone. It's not clear to me whether that is safe, actually.
961 In any case, we expect BB to be non-NULL at least up to register
962 allocation, so disallow a non-NULL BB up to there. Not perfect
963 but better than nothing... */
964 gcc_checking_assert (bb != NULL || reload_completed);
965
966 df_grow_bb_info (df_scan);
967 df_grow_reg_info ();
968
969 /* The block must be marked as dirty now, rather than later as in
970 df_insn_rescan and df_notes_rescan because it may not be there at
971 rescanning time and the mark would blow up.
972 DEBUG_INSNs do not make a block's data flow solution dirty (at
973 worst the LUIDs are no longer contiguous). */
974 if (bb != NULL && NONDEBUG_INSN_P (insn))
975 df_set_bb_dirty (bb);
976
977 /* The client has deferred rescanning. */
978 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
979 {
980 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
981 if (insn_info)
982 {
983 bitmap_clear_bit (&df->insns_to_rescan, uid);
984 bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
985 bitmap_set_bit (&df->insns_to_delete, uid);
986 }
987 if (dump_file)
988 fprintf (dump_file, "deferring deletion of insn with uid = %d.\n", uid);
989 return;
990 }
991
992 if (dump_file)
993 fprintf (dump_file, "deleting insn with uid = %d.\n", uid);
994
995 df_insn_info_delete (uid);
996 }
997
998
999 /* Free all of the refs and the mw_hardregs in COLLECTION_REC. */
1000
1001 static void
1002 df_free_collection_rec (struct df_collection_rec *collection_rec)
1003 {
1004 unsigned int ix;
1005 struct df_scan_problem_data *problem_data
1006 = (struct df_scan_problem_data *) df_scan->problem_data;
1007 df_ref ref;
1008 struct df_mw_hardreg *mw;
1009
1010 FOR_EACH_VEC_ELT (collection_rec->def_vec, ix, ref)
1011 df_free_ref (ref);
1012 FOR_EACH_VEC_ELT (collection_rec->use_vec, ix, ref)
1013 df_free_ref (ref);
1014 FOR_EACH_VEC_ELT (collection_rec->eq_use_vec, ix, ref)
1015 df_free_ref (ref);
1016 FOR_EACH_VEC_ELT (collection_rec->mw_vec, ix, mw)
1017 problem_data->mw_reg_pool->remove (mw);
1018
1019 collection_rec->def_vec.release ();
1020 collection_rec->use_vec.release ();
1021 collection_rec->eq_use_vec.release ();
1022 collection_rec->mw_vec.release ();
1023 }
1024
1025 /* Rescan INSN. Return TRUE if the rescanning produced any changes. */
1026
1027 bool
1028 df_insn_rescan (rtx_insn *insn)
1029 {
1030 unsigned int uid = INSN_UID (insn);
1031 struct df_insn_info *insn_info = NULL;
1032 basic_block bb = BLOCK_FOR_INSN (insn);
1033 struct df_collection_rec collection_rec;
1034
1035 if ((!df) || (!INSN_P (insn)))
1036 return false;
1037
1038 if (!bb)
1039 {
1040 if (dump_file)
1041 fprintf (dump_file, "no bb for insn with uid = %d.\n", uid);
1042 return false;
1043 }
1044
1045 /* The client has disabled rescanning and plans to do it itself. */
1046 if (df->changeable_flags & DF_NO_INSN_RESCAN)
1047 return false;
1048
1049 df_grow_bb_info (df_scan);
1050 df_grow_reg_info ();
1051
1052 insn_info = DF_INSN_UID_SAFE_GET (uid);
1053
1054 /* The client has deferred rescanning. */
1055 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
1056 {
1057 if (!insn_info)
1058 {
1059 insn_info = df_insn_create_insn_record (insn);
1060 insn_info->defs = 0;
1061 insn_info->uses = 0;
1062 insn_info->eq_uses = 0;
1063 insn_info->mw_hardregs = 0;
1064 }
1065 if (dump_file)
1066 fprintf (dump_file, "deferring rescan insn with uid = %d.\n", uid);
1067
1068 bitmap_clear_bit (&df->insns_to_delete, uid);
1069 bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
1070 bitmap_set_bit (&df->insns_to_rescan, INSN_UID (insn));
1071 return false;
1072 }
1073
1074 bitmap_clear_bit (&df->insns_to_delete, uid);
1075 bitmap_clear_bit (&df->insns_to_rescan, uid);
1076 bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
1077 if (insn_info)
1078 {
1079 int luid;
1080 bool the_same = df_insn_refs_verify (&collection_rec, bb, insn, false);
1081 /* If there's no change, return false. */
1082 if (the_same)
1083 {
1084 df_free_collection_rec (&collection_rec);
1085 if (dump_file)
1086 fprintf (dump_file, "verify found no changes in insn with uid = %d.\n", uid);
1087 return false;
1088 }
1089 if (dump_file)
1090 fprintf (dump_file, "rescanning insn with uid = %d.\n", uid);
1091
1092 /* There's change - we need to delete the existing info.
1093 Since the insn isn't moved, we can salvage its LUID. */
1094 luid = DF_INSN_LUID (insn);
1095 df_insn_info_delete (uid);
1096 df_insn_create_insn_record (insn);
1097 DF_INSN_LUID (insn) = luid;
1098 }
1099 else
1100 {
1101 struct df_insn_info *insn_info = df_insn_create_insn_record (insn);
1102 df_insn_refs_collect (&collection_rec, bb, insn_info);
1103 if (dump_file)
1104 fprintf (dump_file, "scanning new insn with uid = %d.\n", uid);
1105 }
1106
1107 df_refs_add_to_chains (&collection_rec, bb, insn, copy_all);
1108 if (!DEBUG_INSN_P (insn))
1109 df_set_bb_dirty (bb);
1110
1111 return true;
1112 }
1113
1114 /* Same as df_insn_rescan, but don't mark the basic block as
1115 dirty. */
1116
1117 bool
1118 df_insn_rescan_debug_internal (rtx_insn *insn)
1119 {
1120 unsigned int uid = INSN_UID (insn);
1121 struct df_insn_info *insn_info;
1122
1123 gcc_assert (DEBUG_INSN_P (insn)
1124 && VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)));
1125
1126 if (!df)
1127 return false;
1128
1129 insn_info = DF_INSN_UID_SAFE_GET (INSN_UID (insn));
1130 if (!insn_info)
1131 return false;
1132
1133 if (dump_file)
1134 fprintf (dump_file, "deleting debug_insn with uid = %d.\n", uid);
1135
1136 bitmap_clear_bit (&df->insns_to_delete, uid);
1137 bitmap_clear_bit (&df->insns_to_rescan, uid);
1138 bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
1139
1140 if (insn_info->defs == 0
1141 && insn_info->uses == 0
1142 && insn_info->eq_uses == 0
1143 && insn_info->mw_hardregs == 0)
1144 return false;
1145
1146 df_mw_hardreg_chain_delete (insn_info->mw_hardregs);
1147
1148 if (df_chain)
1149 {
1150 df_ref_chain_delete_du_chain (insn_info->defs);
1151 df_ref_chain_delete_du_chain (insn_info->uses);
1152 df_ref_chain_delete_du_chain (insn_info->eq_uses);
1153 }
1154
1155 df_ref_chain_delete (insn_info->defs);
1156 df_ref_chain_delete (insn_info->uses);
1157 df_ref_chain_delete (insn_info->eq_uses);
1158
1159 insn_info->defs = 0;
1160 insn_info->uses = 0;
1161 insn_info->eq_uses = 0;
1162 insn_info->mw_hardregs = 0;
1163
1164 return true;
1165 }
1166
1167
1168 /* Rescan all of the insns in the function. Note that the artificial
1169 uses and defs are not touched. This function will destroy def-use
1170 or use-def chains. */
1171
1172 void
1173 df_insn_rescan_all (void)
1174 {
1175 bool no_insn_rescan = false;
1176 bool defer_insn_rescan = false;
1177 basic_block bb;
1178 bitmap_iterator bi;
1179 unsigned int uid;
1180 bitmap_head tmp;
1181
1182 bitmap_initialize (&tmp, &df_bitmap_obstack);
1183
1184 if (df->changeable_flags & DF_NO_INSN_RESCAN)
1185 {
1186 df_clear_flags (DF_NO_INSN_RESCAN);
1187 no_insn_rescan = true;
1188 }
1189
1190 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
1191 {
1192 df_clear_flags (DF_DEFER_INSN_RESCAN);
1193 defer_insn_rescan = true;
1194 }
1195
1196 bitmap_copy (&tmp, &df->insns_to_delete);
1197 EXECUTE_IF_SET_IN_BITMAP (&tmp, 0, uid, bi)
1198 {
1199 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
1200 if (insn_info)
1201 df_insn_info_delete (uid);
1202 }
1203
1204 bitmap_clear (&tmp);
1205 bitmap_clear (&df->insns_to_delete);
1206 bitmap_clear (&df->insns_to_rescan);
1207 bitmap_clear (&df->insns_to_notes_rescan);
1208
1209 FOR_EACH_BB_FN (bb, cfun)
1210 {
1211 rtx_insn *insn;
1212 FOR_BB_INSNS (bb, insn)
1213 {
1214 df_insn_rescan (insn);
1215 }
1216 }
1217
1218 if (no_insn_rescan)
1219 df_set_flags (DF_NO_INSN_RESCAN);
1220 if (defer_insn_rescan)
1221 df_set_flags (DF_DEFER_INSN_RESCAN);
1222 }
1223
1224
1225 /* Process all of the deferred rescans or deletions. */
1226
1227 void
1228 df_process_deferred_rescans (void)
1229 {
1230 bool no_insn_rescan = false;
1231 bool defer_insn_rescan = false;
1232 bitmap_iterator bi;
1233 unsigned int uid;
1234 bitmap_head tmp;
1235
1236 bitmap_initialize (&tmp, &df_bitmap_obstack);
1237
1238 if (df->changeable_flags & DF_NO_INSN_RESCAN)
1239 {
1240 df_clear_flags (DF_NO_INSN_RESCAN);
1241 no_insn_rescan = true;
1242 }
1243
1244 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
1245 {
1246 df_clear_flags (DF_DEFER_INSN_RESCAN);
1247 defer_insn_rescan = true;
1248 }
1249
1250 if (dump_file)
1251 fprintf (dump_file, "starting the processing of deferred insns\n");
1252
1253 bitmap_copy (&tmp, &df->insns_to_delete);
1254 EXECUTE_IF_SET_IN_BITMAP (&tmp, 0, uid, bi)
1255 {
1256 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
1257 if (insn_info)
1258 df_insn_info_delete (uid);
1259 }
1260
1261 bitmap_copy (&tmp, &df->insns_to_rescan);
1262 EXECUTE_IF_SET_IN_BITMAP (&tmp, 0, uid, bi)
1263 {
1264 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
1265 if (insn_info)
1266 df_insn_rescan (insn_info->insn);
1267 }
1268
1269 bitmap_copy (&tmp, &df->insns_to_notes_rescan);
1270 EXECUTE_IF_SET_IN_BITMAP (&tmp, 0, uid, bi)
1271 {
1272 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
1273 if (insn_info)
1274 df_notes_rescan (insn_info->insn);
1275 }
1276
1277 if (dump_file)
1278 fprintf (dump_file, "ending the processing of deferred insns\n");
1279
1280 bitmap_clear (&tmp);
1281 bitmap_clear (&df->insns_to_delete);
1282 bitmap_clear (&df->insns_to_rescan);
1283 bitmap_clear (&df->insns_to_notes_rescan);
1284
1285 if (no_insn_rescan)
1286 df_set_flags (DF_NO_INSN_RESCAN);
1287 if (defer_insn_rescan)
1288 df_set_flags (DF_DEFER_INSN_RESCAN);
1289
1290 /* If someone changed regs_ever_live during this pass, fix up the
1291 entry and exit blocks. */
1292 if (df->redo_entry_and_exit)
1293 {
1294 df_update_entry_exit_and_calls ();
1295 df->redo_entry_and_exit = false;
1296 }
1297 }
1298
1299
1300 /* Count the number of refs. Include the defs if INCLUDE_DEFS. Include
1301 the uses if INCLUDE_USES. Include the eq_uses if
1302 INCLUDE_EQ_USES. */
1303
1304 static unsigned int
1305 df_count_refs (bool include_defs, bool include_uses,
1306 bool include_eq_uses)
1307 {
1308 unsigned int regno;
1309 int size = 0;
1310 unsigned int m = df->regs_inited;
1311
1312 for (regno = 0; regno < m; regno++)
1313 {
1314 if (include_defs)
1315 size += DF_REG_DEF_COUNT (regno);
1316 if (include_uses)
1317 size += DF_REG_USE_COUNT (regno);
1318 if (include_eq_uses)
1319 size += DF_REG_EQ_USE_COUNT (regno);
1320 }
1321 return size;
1322 }
1323
1324
1325 /* Take build ref table for either the uses or defs from the reg-use
1326 or reg-def chains. This version processes the refs in reg order
1327 which is likely to be best if processing the whole function. */
1328
1329 static void
1330 df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
1331 bool include_defs,
1332 bool include_uses,
1333 bool include_eq_uses)
1334 {
1335 unsigned int m = df->regs_inited;
1336 unsigned int regno;
1337 unsigned int offset = 0;
1338 unsigned int start;
1339
1340 if (df->changeable_flags & DF_NO_HARD_REGS)
1341 {
1342 start = FIRST_PSEUDO_REGISTER;
1343 memset (ref_info->begin, 0, sizeof (int) * FIRST_PSEUDO_REGISTER);
1344 memset (ref_info->count, 0, sizeof (int) * FIRST_PSEUDO_REGISTER);
1345 }
1346 else
1347 start = 0;
1348
1349 ref_info->total_size
1350 = df_count_refs (include_defs, include_uses, include_eq_uses);
1351
1352 df_check_and_grow_ref_info (ref_info, 1);
1353
1354 for (regno = start; regno < m; regno++)
1355 {
1356 int count = 0;
1357 ref_info->begin[regno] = offset;
1358 if (include_defs)
1359 {
1360 df_ref ref = DF_REG_DEF_CHAIN (regno);
1361 while (ref)
1362 {
1363 ref_info->refs[offset] = ref;
1364 DF_REF_ID (ref) = offset++;
1365 count++;
1366 ref = DF_REF_NEXT_REG (ref);
1367 gcc_checking_assert (offset < ref_info->refs_size);
1368 }
1369 }
1370 if (include_uses)
1371 {
1372 df_ref ref = DF_REG_USE_CHAIN (regno);
1373 while (ref)
1374 {
1375 ref_info->refs[offset] = ref;
1376 DF_REF_ID (ref) = offset++;
1377 count++;
1378 ref = DF_REF_NEXT_REG (ref);
1379 gcc_checking_assert (offset < ref_info->refs_size);
1380 }
1381 }
1382 if (include_eq_uses)
1383 {
1384 df_ref ref = DF_REG_EQ_USE_CHAIN (regno);
1385 while (ref)
1386 {
1387 ref_info->refs[offset] = ref;
1388 DF_REF_ID (ref) = offset++;
1389 count++;
1390 ref = DF_REF_NEXT_REG (ref);
1391 gcc_checking_assert (offset < ref_info->refs_size);
1392 }
1393 }
1394 ref_info->count[regno] = count;
1395 }
1396
1397 /* The bitmap size is not decremented when refs are deleted. So
1398 reset it now that we have squished out all of the empty
1399 slots. */
1400 ref_info->table_size = offset;
1401 }
1402
1403
1404 /* Take build ref table for either the uses or defs from the reg-use
1405 or reg-def chains. This version processes the refs in insn order
1406 which is likely to be best if processing some segment of the
1407 function. */
1408
1409 static void
1410 df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
1411 bool include_defs,
1412 bool include_uses,
1413 bool include_eq_uses)
1414 {
1415 bitmap_iterator bi;
1416 unsigned int bb_index;
1417 unsigned int m = df->regs_inited;
1418 unsigned int offset = 0;
1419 unsigned int r;
1420 unsigned int start
1421 = (df->changeable_flags & DF_NO_HARD_REGS) ? FIRST_PSEUDO_REGISTER : 0;
1422
1423 memset (ref_info->begin, 0, sizeof (int) * df->regs_inited);
1424 memset (ref_info->count, 0, sizeof (int) * df->regs_inited);
1425
1426 ref_info->total_size = df_count_refs (include_defs, include_uses, include_eq_uses);
1427 df_check_and_grow_ref_info (ref_info, 1);
1428
1429 EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, bb_index, bi)
1430 {
1431 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
1432 rtx_insn *insn;
1433 df_ref def, use;
1434
1435 if (include_defs)
1436 FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
1437 {
1438 unsigned int regno = DF_REF_REGNO (def);
1439 ref_info->count[regno]++;
1440 }
1441 if (include_uses)
1442 FOR_EACH_ARTIFICIAL_USE (use, bb_index)
1443 {
1444 unsigned int regno = DF_REF_REGNO (use);
1445 ref_info->count[regno]++;
1446 }
1447
1448 FOR_BB_INSNS (bb, insn)
1449 {
1450 if (INSN_P (insn))
1451 {
1452 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
1453
1454 if (include_defs)
1455 FOR_EACH_INSN_INFO_DEF (def, insn_info)
1456 {
1457 unsigned int regno = DF_REF_REGNO (def);
1458 ref_info->count[regno]++;
1459 }
1460 if (include_uses)
1461 FOR_EACH_INSN_INFO_USE (use, insn_info)
1462 {
1463 unsigned int regno = DF_REF_REGNO (use);
1464 ref_info->count[regno]++;
1465 }
1466 if (include_eq_uses)
1467 FOR_EACH_INSN_INFO_EQ_USE (use, insn_info)
1468 {
1469 unsigned int regno = DF_REF_REGNO (use);
1470 ref_info->count[regno]++;
1471 }
1472 }
1473 }
1474 }
1475
1476 for (r = start; r < m; r++)
1477 {
1478 ref_info->begin[r] = offset;
1479 offset += ref_info->count[r];
1480 ref_info->count[r] = 0;
1481 }
1482
1483 EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, bb_index, bi)
1484 {
1485 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
1486 rtx_insn *insn;
1487 df_ref def, use;
1488
1489 if (include_defs)
1490 FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
1491 {
1492 unsigned int regno = DF_REF_REGNO (def);
1493 if (regno >= start)
1494 {
1495 unsigned int id
1496 = ref_info->begin[regno] + ref_info->count[regno]++;
1497 DF_REF_ID (def) = id;
1498 ref_info->refs[id] = def;
1499 }
1500 }
1501 if (include_uses)
1502 FOR_EACH_ARTIFICIAL_USE (use, bb_index)
1503 {
1504 unsigned int regno = DF_REF_REGNO (def);
1505 if (regno >= start)
1506 {
1507 unsigned int id
1508 = ref_info->begin[regno] + ref_info->count[regno]++;
1509 DF_REF_ID (use) = id;
1510 ref_info->refs[id] = use;
1511 }
1512 }
1513
1514 FOR_BB_INSNS (bb, insn)
1515 {
1516 if (INSN_P (insn))
1517 {
1518 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
1519
1520 if (include_defs)
1521 FOR_EACH_INSN_INFO_DEF (def, insn_info)
1522 {
1523 unsigned int regno = DF_REF_REGNO (def);
1524 if (regno >= start)
1525 {
1526 unsigned int id
1527 = ref_info->begin[regno] + ref_info->count[regno]++;
1528 DF_REF_ID (def) = id;
1529 ref_info->refs[id] = def;
1530 }
1531 }
1532 if (include_uses)
1533 FOR_EACH_INSN_INFO_USE (use, insn_info)
1534 {
1535 unsigned int regno = DF_REF_REGNO (use);
1536 if (regno >= start)
1537 {
1538 unsigned int id
1539 = ref_info->begin[regno] + ref_info->count[regno]++;
1540 DF_REF_ID (use) = id;
1541 ref_info->refs[id] = use;
1542 }
1543 }
1544 if (include_eq_uses)
1545 FOR_EACH_INSN_INFO_EQ_USE (use, insn_info)
1546 {
1547 unsigned int regno = DF_REF_REGNO (use);
1548 if (regno >= start)
1549 {
1550 unsigned int id
1551 = ref_info->begin[regno] + ref_info->count[regno]++;
1552 DF_REF_ID (use) = id;
1553 ref_info->refs[id] = use;
1554 }
1555 }
1556 }
1557 }
1558 }
1559
1560 /* The bitmap size is not decremented when refs are deleted. So
1561 reset it now that we have squished out all of the empty
1562 slots. */
1563
1564 ref_info->table_size = offset;
1565 }
1566
1567 /* Take build ref table for either the uses or defs from the reg-use
1568 or reg-def chains. */
1569
1570 static void
1571 df_reorganize_refs_by_reg (struct df_ref_info *ref_info,
1572 bool include_defs,
1573 bool include_uses,
1574 bool include_eq_uses)
1575 {
1576 if (df->analyze_subset)
1577 df_reorganize_refs_by_reg_by_insn (ref_info, include_defs,
1578 include_uses, include_eq_uses);
1579 else
1580 df_reorganize_refs_by_reg_by_reg (ref_info, include_defs,
1581 include_uses, include_eq_uses);
1582 }
1583
1584
1585 /* Add the refs in REF_VEC to the table in REF_INFO starting at OFFSET. */
1586 static unsigned int
1587 df_add_refs_to_table (unsigned int offset,
1588 struct df_ref_info *ref_info,
1589 df_ref ref)
1590 {
1591 for (; ref; ref = DF_REF_NEXT_LOC (ref))
1592 if (!(df->changeable_flags & DF_NO_HARD_REGS)
1593 || (DF_REF_REGNO (ref) >= FIRST_PSEUDO_REGISTER))
1594 {
1595 ref_info->refs[offset] = ref;
1596 DF_REF_ID (ref) = offset++;
1597 }
1598 return offset;
1599 }
1600
1601
1602 /* Count the number of refs in all of the insns of BB. Include the
1603 defs if INCLUDE_DEFS. Include the uses if INCLUDE_USES. Include the
1604 eq_uses if INCLUDE_EQ_USES. */
1605
1606 static unsigned int
1607 df_reorganize_refs_by_insn_bb (basic_block bb, unsigned int offset,
1608 struct df_ref_info *ref_info,
1609 bool include_defs, bool include_uses,
1610 bool include_eq_uses)
1611 {
1612 rtx_insn *insn;
1613
1614 if (include_defs)
1615 offset = df_add_refs_to_table (offset, ref_info,
1616 df_get_artificial_defs (bb->index));
1617 if (include_uses)
1618 offset = df_add_refs_to_table (offset, ref_info,
1619 df_get_artificial_uses (bb->index));
1620
1621 FOR_BB_INSNS (bb, insn)
1622 if (INSN_P (insn))
1623 {
1624 unsigned int uid = INSN_UID (insn);
1625 if (include_defs)
1626 offset = df_add_refs_to_table (offset, ref_info,
1627 DF_INSN_UID_DEFS (uid));
1628 if (include_uses)
1629 offset = df_add_refs_to_table (offset, ref_info,
1630 DF_INSN_UID_USES (uid));
1631 if (include_eq_uses)
1632 offset = df_add_refs_to_table (offset, ref_info,
1633 DF_INSN_UID_EQ_USES (uid));
1634 }
1635 return offset;
1636 }
1637
1638
1639 /* Organize the refs by insn into the table in REF_INFO. If
1640 blocks_to_analyze is defined, use that set, otherwise the entire
1641 program. Include the defs if INCLUDE_DEFS. Include the uses if
1642 INCLUDE_USES. Include the eq_uses if INCLUDE_EQ_USES. */
1643
1644 static void
1645 df_reorganize_refs_by_insn (struct df_ref_info *ref_info,
1646 bool include_defs, bool include_uses,
1647 bool include_eq_uses)
1648 {
1649 basic_block bb;
1650 unsigned int offset = 0;
1651
1652 ref_info->total_size = df_count_refs (include_defs, include_uses, include_eq_uses);
1653 df_check_and_grow_ref_info (ref_info, 1);
1654 if (df->blocks_to_analyze)
1655 {
1656 bitmap_iterator bi;
1657 unsigned int index;
1658
1659 EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, index, bi)
1660 {
1661 offset = df_reorganize_refs_by_insn_bb (BASIC_BLOCK_FOR_FN (cfun,
1662 index),
1663 offset, ref_info,
1664 include_defs, include_uses,
1665 include_eq_uses);
1666 }
1667
1668 ref_info->table_size = offset;
1669 }
1670 else
1671 {
1672 FOR_ALL_BB_FN (bb, cfun)
1673 offset = df_reorganize_refs_by_insn_bb (bb, offset, ref_info,
1674 include_defs, include_uses,
1675 include_eq_uses);
1676 ref_info->table_size = offset;
1677 }
1678 }
1679
1680
1681 /* If the use refs in DF are not organized, reorganize them. */
1682
1683 void
1684 df_maybe_reorganize_use_refs (enum df_ref_order order)
1685 {
1686 if (order == df->use_info.ref_order)
1687 return;
1688
1689 switch (order)
1690 {
1691 case DF_REF_ORDER_BY_REG:
1692 df_reorganize_refs_by_reg (&df->use_info, false, true, false);
1693 break;
1694
1695 case DF_REF_ORDER_BY_REG_WITH_NOTES:
1696 df_reorganize_refs_by_reg (&df->use_info, false, true, true);
1697 break;
1698
1699 case DF_REF_ORDER_BY_INSN:
1700 df_reorganize_refs_by_insn (&df->use_info, false, true, false);
1701 break;
1702
1703 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
1704 df_reorganize_refs_by_insn (&df->use_info, false, true, true);
1705 break;
1706
1707 case DF_REF_ORDER_NO_TABLE:
1708 free (df->use_info.refs);
1709 df->use_info.refs = NULL;
1710 df->use_info.refs_size = 0;
1711 break;
1712
1713 case DF_REF_ORDER_UNORDERED:
1714 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
1715 gcc_unreachable ();
1716 break;
1717 }
1718
1719 df->use_info.ref_order = order;
1720 }
1721
1722
1723 /* If the def refs in DF are not organized, reorganize them. */
1724
1725 void
1726 df_maybe_reorganize_def_refs (enum df_ref_order order)
1727 {
1728 if (order == df->def_info.ref_order)
1729 return;
1730
1731 switch (order)
1732 {
1733 case DF_REF_ORDER_BY_REG:
1734 df_reorganize_refs_by_reg (&df->def_info, true, false, false);
1735 break;
1736
1737 case DF_REF_ORDER_BY_INSN:
1738 df_reorganize_refs_by_insn (&df->def_info, true, false, false);
1739 break;
1740
1741 case DF_REF_ORDER_NO_TABLE:
1742 free (df->def_info.refs);
1743 df->def_info.refs = NULL;
1744 df->def_info.refs_size = 0;
1745 break;
1746
1747 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
1748 case DF_REF_ORDER_BY_REG_WITH_NOTES:
1749 case DF_REF_ORDER_UNORDERED:
1750 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
1751 gcc_unreachable ();
1752 break;
1753 }
1754
1755 df->def_info.ref_order = order;
1756 }
1757
1758
1759 /* Change all of the basic block references in INSN to use the insn's
1760 current basic block. This function is called from routines that move
1761 instructions from one block to another. */
1762
1763 void
1764 df_insn_change_bb (rtx_insn *insn, basic_block new_bb)
1765 {
1766 basic_block old_bb = BLOCK_FOR_INSN (insn);
1767 struct df_insn_info *insn_info;
1768 unsigned int uid = INSN_UID (insn);
1769
1770 if (old_bb == new_bb)
1771 return;
1772
1773 set_block_for_insn (insn, new_bb);
1774
1775 if (!df)
1776 return;
1777
1778 if (dump_file)
1779 fprintf (dump_file, "changing bb of uid %d\n", uid);
1780
1781 insn_info = DF_INSN_UID_SAFE_GET (uid);
1782 if (insn_info == NULL)
1783 {
1784 if (dump_file)
1785 fprintf (dump_file, " unscanned insn\n");
1786 df_insn_rescan (insn);
1787 return;
1788 }
1789
1790 if (!INSN_P (insn))
1791 return;
1792
1793 df_set_bb_dirty (new_bb);
1794 if (old_bb)
1795 {
1796 if (dump_file)
1797 fprintf (dump_file, " from %d to %d\n",
1798 old_bb->index, new_bb->index);
1799 df_set_bb_dirty (old_bb);
1800 }
1801 else
1802 if (dump_file)
1803 fprintf (dump_file, " to %d\n", new_bb->index);
1804 }
1805
1806
1807 /* Helper function for df_ref_change_reg_with_loc. */
1808
1809 static void
1810 df_ref_change_reg_with_loc_1 (struct df_reg_info *old_df,
1811 struct df_reg_info *new_df,
1812 unsigned int new_regno, rtx loc)
1813 {
1814 df_ref the_ref = old_df->reg_chain;
1815
1816 while (the_ref)
1817 {
1818 if ((!DF_REF_IS_ARTIFICIAL (the_ref))
1819 && DF_REF_LOC (the_ref)
1820 && (*DF_REF_LOC (the_ref) == loc))
1821 {
1822 df_ref next_ref = DF_REF_NEXT_REG (the_ref);
1823 df_ref prev_ref = DF_REF_PREV_REG (the_ref);
1824 df_ref *ref_ptr;
1825 struct df_insn_info *insn_info = DF_REF_INSN_INFO (the_ref);
1826
1827 DF_REF_REGNO (the_ref) = new_regno;
1828 DF_REF_REG (the_ref) = regno_reg_rtx[new_regno];
1829
1830 /* Pull the_ref out of the old regno chain. */
1831 if (prev_ref)
1832 DF_REF_NEXT_REG (prev_ref) = next_ref;
1833 else
1834 old_df->reg_chain = next_ref;
1835 if (next_ref)
1836 DF_REF_PREV_REG (next_ref) = prev_ref;
1837 old_df->n_refs--;
1838
1839 /* Put the ref into the new regno chain. */
1840 DF_REF_PREV_REG (the_ref) = NULL;
1841 DF_REF_NEXT_REG (the_ref) = new_df->reg_chain;
1842 if (new_df->reg_chain)
1843 DF_REF_PREV_REG (new_df->reg_chain) = the_ref;
1844 new_df->reg_chain = the_ref;
1845 new_df->n_refs++;
1846 if (DF_REF_BB (the_ref))
1847 df_set_bb_dirty (DF_REF_BB (the_ref));
1848
1849 /* Need to sort the record again that the ref was in because
1850 the regno is a sorting key. First, find the right
1851 record. */
1852 if (DF_REF_REG_DEF_P (the_ref))
1853 ref_ptr = &insn_info->defs;
1854 else if (DF_REF_FLAGS (the_ref) & DF_REF_IN_NOTE)
1855 ref_ptr = &insn_info->eq_uses;
1856 else
1857 ref_ptr = &insn_info->uses;
1858 if (dump_file)
1859 fprintf (dump_file, "changing reg in insn %d\n",
1860 DF_REF_INSN_UID (the_ref));
1861
1862 /* Stop if we find the current reference or where the reference
1863 needs to be. */
1864 while (*ref_ptr != the_ref && df_ref_compare (*ref_ptr, the_ref) < 0)
1865 ref_ptr = &DF_REF_NEXT_LOC (*ref_ptr);
1866 if (*ref_ptr != the_ref)
1867 {
1868 /* The reference needs to be promoted up the list. */
1869 df_ref next = DF_REF_NEXT_LOC (the_ref);
1870 DF_REF_NEXT_LOC (the_ref) = *ref_ptr;
1871 *ref_ptr = the_ref;
1872 do
1873 ref_ptr = &DF_REF_NEXT_LOC (*ref_ptr);
1874 while (*ref_ptr != the_ref);
1875 *ref_ptr = next;
1876 }
1877 else if (DF_REF_NEXT_LOC (the_ref)
1878 && df_ref_compare (the_ref, DF_REF_NEXT_LOC (the_ref)) > 0)
1879 {
1880 /* The reference needs to be demoted down the list. */
1881 *ref_ptr = DF_REF_NEXT_LOC (the_ref);
1882 do
1883 ref_ptr = &DF_REF_NEXT_LOC (*ref_ptr);
1884 while (*ref_ptr && df_ref_compare (the_ref, *ref_ptr) > 0);
1885 DF_REF_NEXT_LOC (the_ref) = *ref_ptr;
1886 *ref_ptr = the_ref;
1887 }
1888
1889 the_ref = next_ref;
1890 }
1891 else
1892 the_ref = DF_REF_NEXT_REG (the_ref);
1893 }
1894 }
1895
1896
1897 /* Change the regno of register LOC to NEW_REGNO and update the df
1898 information accordingly. Refs that do not match LOC are not changed
1899 which means that artificial refs are not changed since they have no loc.
1900 This call is to support the SET_REGNO macro. */
1901
1902 void
1903 df_ref_change_reg_with_loc (rtx loc, unsigned int new_regno)
1904 {
1905 unsigned int old_regno = REGNO (loc);
1906 if (old_regno == new_regno)
1907 return;
1908
1909 if (df)
1910 {
1911 df_grow_reg_info ();
1912
1913 df_ref_change_reg_with_loc_1 (DF_REG_DEF_GET (old_regno),
1914 DF_REG_DEF_GET (new_regno),
1915 new_regno, loc);
1916 df_ref_change_reg_with_loc_1 (DF_REG_USE_GET (old_regno),
1917 DF_REG_USE_GET (new_regno),
1918 new_regno, loc);
1919 df_ref_change_reg_with_loc_1 (DF_REG_EQ_USE_GET (old_regno),
1920 DF_REG_EQ_USE_GET (new_regno),
1921 new_regno, loc);
1922 }
1923 set_mode_and_regno (loc, GET_MODE (loc), new_regno);
1924 }
1925
1926
1927 /* Delete the mw_hardregs that point into the eq_notes. */
1928
1929 static void
1930 df_mw_hardreg_chain_delete_eq_uses (struct df_insn_info *insn_info)
1931 {
1932 struct df_mw_hardreg **mw_ptr = &insn_info->mw_hardregs;
1933 struct df_scan_problem_data *problem_data
1934 = (struct df_scan_problem_data *) df_scan->problem_data;
1935
1936 while (*mw_ptr)
1937 {
1938 df_mw_hardreg *mw = *mw_ptr;
1939 if (mw->flags & DF_REF_IN_NOTE)
1940 {
1941 *mw_ptr = DF_MWS_NEXT (mw);
1942 problem_data->mw_reg_pool->remove (mw);
1943 }
1944 else
1945 mw_ptr = &DF_MWS_NEXT (mw);
1946 }
1947 }
1948
1949
1950 /* Rescan only the REG_EQUIV/REG_EQUAL notes part of INSN. */
1951
1952 void
1953 df_notes_rescan (rtx_insn *insn)
1954 {
1955 struct df_insn_info *insn_info;
1956 unsigned int uid = INSN_UID (insn);
1957
1958 if (!df)
1959 return;
1960
1961 /* The client has disabled rescanning and plans to do it itself. */
1962 if (df->changeable_flags & DF_NO_INSN_RESCAN)
1963 return;
1964
1965 /* Do nothing if the insn hasn't been emitted yet. */
1966 if (!BLOCK_FOR_INSN (insn))
1967 return;
1968
1969 df_grow_bb_info (df_scan);
1970 df_grow_reg_info ();
1971
1972 insn_info = DF_INSN_UID_SAFE_GET (INSN_UID (insn));
1973
1974 /* The client has deferred rescanning. */
1975 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
1976 {
1977 if (!insn_info)
1978 {
1979 insn_info = df_insn_create_insn_record (insn);
1980 insn_info->defs = 0;
1981 insn_info->uses = 0;
1982 insn_info->eq_uses = 0;
1983 insn_info->mw_hardregs = 0;
1984 }
1985
1986 bitmap_clear_bit (&df->insns_to_delete, uid);
1987 /* If the insn is set to be rescanned, it does not need to also
1988 be notes rescanned. */
1989 if (!bitmap_bit_p (&df->insns_to_rescan, uid))
1990 bitmap_set_bit (&df->insns_to_notes_rescan, INSN_UID (insn));
1991 return;
1992 }
1993
1994 bitmap_clear_bit (&df->insns_to_delete, uid);
1995 bitmap_clear_bit (&df->insns_to_notes_rescan, uid);
1996
1997 if (insn_info)
1998 {
1999 basic_block bb = BLOCK_FOR_INSN (insn);
2000 rtx note;
2001 struct df_collection_rec collection_rec;
2002 unsigned int i;
2003
2004 df_mw_hardreg_chain_delete_eq_uses (insn_info);
2005 df_ref_chain_delete (insn_info->eq_uses);
2006 insn_info->eq_uses = NULL;
2007
2008 /* Process REG_EQUIV/REG_EQUAL notes */
2009 for (note = REG_NOTES (insn); note;
2010 note = XEXP (note, 1))
2011 {
2012 switch (REG_NOTE_KIND (note))
2013 {
2014 case REG_EQUIV:
2015 case REG_EQUAL:
2016 df_uses_record (&collection_rec,
2017 &XEXP (note, 0), DF_REF_REG_USE,
2018 bb, insn_info, DF_REF_IN_NOTE);
2019 default:
2020 break;
2021 }
2022 }
2023
2024 /* Find some place to put any new mw_hardregs. */
2025 df_canonize_collection_rec (&collection_rec);
2026 struct df_mw_hardreg **mw_ptr = &insn_info->mw_hardregs, *mw;
2027 FOR_EACH_VEC_ELT (collection_rec.mw_vec, i, mw)
2028 {
2029 while (*mw_ptr && df_mw_compare (*mw_ptr, mw) < 0)
2030 mw_ptr = &DF_MWS_NEXT (*mw_ptr);
2031 DF_MWS_NEXT (mw) = *mw_ptr;
2032 *mw_ptr = mw;
2033 mw_ptr = &DF_MWS_NEXT (mw);
2034 }
2035 df_refs_add_to_chains (&collection_rec, bb, insn, copy_eq_uses);
2036 }
2037 else
2038 df_insn_rescan (insn);
2039
2040 }
2041
2042 \f
2043 /*----------------------------------------------------------------------------
2044 Hard core instruction scanning code. No external interfaces here,
2045 just a lot of routines that look inside insns.
2046 ----------------------------------------------------------------------------*/
2047
2048
2049 /* Return true if the contents of two df_ref's are identical.
2050 It ignores DF_REF_MARKER. */
2051
2052 static bool
2053 df_ref_equal_p (df_ref ref1, df_ref ref2)
2054 {
2055 if (!ref2)
2056 return false;
2057
2058 if (ref1 == ref2)
2059 return true;
2060
2061 if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2)
2062 || DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2)
2063 || DF_REF_REG (ref1) != DF_REF_REG (ref2)
2064 || DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2)
2065 || ((DF_REF_FLAGS (ref1) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG))
2066 != (DF_REF_FLAGS (ref2) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG)))
2067 || DF_REF_BB (ref1) != DF_REF_BB (ref2)
2068 || DF_REF_INSN_INFO (ref1) != DF_REF_INSN_INFO (ref2))
2069 return false;
2070
2071 switch (DF_REF_CLASS (ref1))
2072 {
2073 case DF_REF_ARTIFICIAL:
2074 case DF_REF_BASE:
2075 return true;
2076
2077 case DF_REF_REGULAR:
2078 return DF_REF_LOC (ref1) == DF_REF_LOC (ref2);
2079
2080 default:
2081 gcc_unreachable ();
2082 }
2083 return false;
2084 }
2085
2086
2087 /* Compare REF1 and REF2 for sorting. This is only called from places
2088 where all of the refs are of the same type, in the same insn, and
2089 have the same bb. So these fields are not checked. */
2090
2091 static int
2092 df_ref_compare (df_ref ref1, df_ref ref2)
2093 {
2094 if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2))
2095 return (int)DF_REF_CLASS (ref1) - (int)DF_REF_CLASS (ref2);
2096
2097 if (DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2))
2098 return (int)DF_REF_REGNO (ref1) - (int)DF_REF_REGNO (ref2);
2099
2100 if (DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2))
2101 return (int)DF_REF_TYPE (ref1) - (int)DF_REF_TYPE (ref2);
2102
2103 if (DF_REF_REG (ref1) != DF_REF_REG (ref2))
2104 return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
2105
2106 /* Cannot look at the LOC field on artificial refs. */
2107 if (DF_REF_CLASS (ref1) != DF_REF_ARTIFICIAL
2108 && DF_REF_LOC (ref1) != DF_REF_LOC (ref2))
2109 return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
2110
2111 if (DF_REF_FLAGS (ref1) != DF_REF_FLAGS (ref2))
2112 {
2113 /* If two refs are identical except that one of them has is from
2114 a mw and one is not, we need to have the one with the mw
2115 first. */
2116 if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_MW_HARDREG) ==
2117 DF_REF_FLAGS_IS_SET (ref2, DF_REF_MW_HARDREG))
2118 return DF_REF_FLAGS (ref1) - DF_REF_FLAGS (ref2);
2119 else if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_MW_HARDREG))
2120 return -1;
2121 else
2122 return 1;
2123 }
2124
2125 return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
2126 }
2127
2128 /* Like df_ref_compare, but compare two df_ref* pointers R1 and R2. */
2129
2130 static int
2131 df_ref_ptr_compare (const void *r1, const void *r2)
2132 {
2133 return df_ref_compare (*(const df_ref *) r1, *(const df_ref *) r2);
2134 }
2135
2136 /* Sort and compress a set of refs. */
2137
2138 static void
2139 df_sort_and_compress_refs (vec<df_ref, va_heap> *ref_vec)
2140 {
2141 unsigned int count;
2142 unsigned int i;
2143 unsigned int dist = 0;
2144
2145 count = ref_vec->length ();
2146
2147 /* If there are 1 or 0 elements, there is nothing to do. */
2148 if (count < 2)
2149 return;
2150 else if (count == 2)
2151 {
2152 df_ref r0 = (*ref_vec)[0];
2153 df_ref r1 = (*ref_vec)[1];
2154 if (df_ref_compare (r0, r1) > 0)
2155 std::swap ((*ref_vec)[0], (*ref_vec)[1]);
2156 }
2157 else
2158 {
2159 for (i = 0; i < count - 1; i++)
2160 {
2161 df_ref r0 = (*ref_vec)[i];
2162 df_ref r1 = (*ref_vec)[i + 1];
2163 if (df_ref_compare (r0, r1) >= 0)
2164 break;
2165 }
2166 /* If the array is already strictly ordered,
2167 which is the most common case for large COUNT case
2168 (which happens for CALL INSNs),
2169 no need to sort and filter out duplicate.
2170 Simply return the count.
2171 Make sure DF_GET_ADD_REFS adds refs in the increasing order
2172 of DF_REF_COMPARE. */
2173 if (i == count - 1)
2174 return;
2175 ref_vec->qsort (df_ref_ptr_compare);
2176 }
2177
2178 for (i=0; i<count-dist; i++)
2179 {
2180 /* Find the next ref that is not equal to the current ref. */
2181 while (i + dist + 1 < count
2182 && df_ref_equal_p ((*ref_vec)[i],
2183 (*ref_vec)[i + dist + 1]))
2184 {
2185 df_free_ref ((*ref_vec)[i + dist + 1]);
2186 dist++;
2187 }
2188 /* Copy it down to the next position. */
2189 if (dist && i + dist + 1 < count)
2190 (*ref_vec)[i + 1] = (*ref_vec)[i + dist + 1];
2191 }
2192
2193 count -= dist;
2194 ref_vec->truncate (count);
2195 }
2196
2197
2198 /* Return true if the contents of two df_ref's are identical.
2199 It ignores DF_REF_MARKER. */
2200
2201 static bool
2202 df_mw_equal_p (struct df_mw_hardreg *mw1, struct df_mw_hardreg *mw2)
2203 {
2204 if (!mw2)
2205 return false;
2206 return (mw1 == mw2) ||
2207 (mw1->mw_reg == mw2->mw_reg
2208 && mw1->type == mw2->type
2209 && mw1->flags == mw2->flags
2210 && mw1->start_regno == mw2->start_regno
2211 && mw1->end_regno == mw2->end_regno);
2212 }
2213
2214
2215 /* Compare MW1 and MW2 for sorting. */
2216
2217 static int
2218 df_mw_compare (const df_mw_hardreg *mw1, const df_mw_hardreg *mw2)
2219 {
2220 if (mw1->type != mw2->type)
2221 return mw1->type - mw2->type;
2222
2223 if (mw1->flags != mw2->flags)
2224 return mw1->flags - mw2->flags;
2225
2226 if (mw1->start_regno != mw2->start_regno)
2227 return mw1->start_regno - mw2->start_regno;
2228
2229 if (mw1->end_regno != mw2->end_regno)
2230 return mw1->end_regno - mw2->end_regno;
2231
2232 if (mw1->mw_reg != mw2->mw_reg)
2233 return mw1->mw_order - mw2->mw_order;
2234
2235 return 0;
2236 }
2237
2238 /* Like df_mw_compare, but compare two df_mw_hardreg** pointers R1 and R2. */
2239
2240 static int
2241 df_mw_ptr_compare (const void *m1, const void *m2)
2242 {
2243 return df_mw_compare (*(const df_mw_hardreg *const *) m1,
2244 *(const df_mw_hardreg *const *) m2);
2245 }
2246
2247 /* Sort and compress a set of refs. */
2248
2249 static void
2250 df_sort_and_compress_mws (vec<df_mw_hardreg_ptr, va_heap> *mw_vec)
2251 {
2252 unsigned int count;
2253 struct df_scan_problem_data *problem_data
2254 = (struct df_scan_problem_data *) df_scan->problem_data;
2255 unsigned int i;
2256 unsigned int dist = 0;
2257
2258 count = mw_vec->length ();
2259 if (count < 2)
2260 return;
2261 else if (count == 2)
2262 {
2263 struct df_mw_hardreg *m0 = (*mw_vec)[0];
2264 struct df_mw_hardreg *m1 = (*mw_vec)[1];
2265 if (df_mw_compare (m0, m1) > 0)
2266 {
2267 struct df_mw_hardreg *tmp = (*mw_vec)[0];
2268 (*mw_vec)[0] = (*mw_vec)[1];
2269 (*mw_vec)[1] = tmp;
2270 }
2271 }
2272 else
2273 mw_vec->qsort (df_mw_ptr_compare);
2274
2275 for (i=0; i<count-dist; i++)
2276 {
2277 /* Find the next ref that is not equal to the current ref. */
2278 while (i + dist + 1 < count
2279 && df_mw_equal_p ((*mw_vec)[i], (*mw_vec)[i + dist + 1]))
2280 {
2281 problem_data->mw_reg_pool->remove ((*mw_vec)[i + dist + 1]);
2282 dist++;
2283 }
2284 /* Copy it down to the next position. */
2285 if (dist && i + dist + 1 < count)
2286 (*mw_vec)[i + 1] = (*mw_vec)[i + dist + 1];
2287 }
2288
2289 count -= dist;
2290 mw_vec->truncate (count);
2291 }
2292
2293
2294 /* Sort and remove duplicates from the COLLECTION_REC. */
2295
2296 static void
2297 df_canonize_collection_rec (struct df_collection_rec *collection_rec)
2298 {
2299 df_sort_and_compress_refs (&collection_rec->def_vec);
2300 df_sort_and_compress_refs (&collection_rec->use_vec);
2301 df_sort_and_compress_refs (&collection_rec->eq_use_vec);
2302 df_sort_and_compress_mws (&collection_rec->mw_vec);
2303 }
2304
2305
2306 /* Add the new df_ref to appropriate reg_info/ref_info chains. */
2307
2308 static void
2309 df_install_ref (df_ref this_ref,
2310 struct df_reg_info *reg_info,
2311 struct df_ref_info *ref_info,
2312 bool add_to_table)
2313 {
2314 unsigned int regno = DF_REF_REGNO (this_ref);
2315 /* Add the ref to the reg_{def,use,eq_use} chain. */
2316 df_ref head = reg_info->reg_chain;
2317
2318 reg_info->reg_chain = this_ref;
2319 reg_info->n_refs++;
2320
2321 if (DF_REF_FLAGS_IS_SET (this_ref, DF_HARD_REG_LIVE))
2322 {
2323 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
2324 df->hard_regs_live_count[regno]++;
2325 }
2326
2327 gcc_checking_assert (DF_REF_NEXT_REG (this_ref) == NULL
2328 && DF_REF_PREV_REG (this_ref) == NULL);
2329
2330 DF_REF_NEXT_REG (this_ref) = head;
2331
2332 /* We cannot actually link to the head of the chain. */
2333 DF_REF_PREV_REG (this_ref) = NULL;
2334
2335 if (head)
2336 DF_REF_PREV_REG (head) = this_ref;
2337
2338 if (add_to_table)
2339 {
2340 gcc_assert (ref_info->ref_order != DF_REF_ORDER_NO_TABLE);
2341 df_check_and_grow_ref_info (ref_info, 1);
2342 DF_REF_ID (this_ref) = ref_info->table_size;
2343 /* Add the ref to the big array of defs. */
2344 ref_info->refs[ref_info->table_size] = this_ref;
2345 ref_info->table_size++;
2346 }
2347 else
2348 DF_REF_ID (this_ref) = -1;
2349
2350 ref_info->total_size++;
2351 }
2352
2353
2354 /* This function takes one of the groups of refs (defs, uses or
2355 eq_uses) and installs the entire group into the insn. It also adds
2356 each of these refs into the appropriate chains. */
2357
2358 static df_ref
2359 df_install_refs (basic_block bb,
2360 const vec<df_ref, va_heap> *old_vec,
2361 struct df_reg_info **reg_info,
2362 struct df_ref_info *ref_info,
2363 bool is_notes)
2364 {
2365 unsigned int count = old_vec->length ();
2366 if (count)
2367 {
2368 bool add_to_table;
2369 df_ref this_ref;
2370 unsigned int ix;
2371
2372 switch (ref_info->ref_order)
2373 {
2374 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
2375 case DF_REF_ORDER_BY_REG_WITH_NOTES:
2376 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
2377 ref_info->ref_order = DF_REF_ORDER_UNORDERED_WITH_NOTES;
2378 add_to_table = true;
2379 break;
2380 case DF_REF_ORDER_UNORDERED:
2381 case DF_REF_ORDER_BY_REG:
2382 case DF_REF_ORDER_BY_INSN:
2383 ref_info->ref_order = DF_REF_ORDER_UNORDERED;
2384 add_to_table = !is_notes;
2385 break;
2386 default:
2387 add_to_table = false;
2388 break;
2389 }
2390
2391 /* Do not add if ref is not in the right blocks. */
2392 if (add_to_table && df->analyze_subset)
2393 add_to_table = bitmap_bit_p (df->blocks_to_analyze, bb->index);
2394
2395 FOR_EACH_VEC_ELT (*old_vec, ix, this_ref)
2396 {
2397 DF_REF_NEXT_LOC (this_ref) = (ix + 1 < old_vec->length ()
2398 ? (*old_vec)[ix + 1]
2399 : NULL);
2400 df_install_ref (this_ref, reg_info[DF_REF_REGNO (this_ref)],
2401 ref_info, add_to_table);
2402 }
2403 return (*old_vec)[0];
2404 }
2405 else
2406 return 0;
2407 }
2408
2409
2410 /* This function takes the mws installs the entire group into the
2411 insn. */
2412
2413 static struct df_mw_hardreg *
2414 df_install_mws (const vec<df_mw_hardreg_ptr, va_heap> *old_vec)
2415 {
2416 unsigned int count = old_vec->length ();
2417 if (count)
2418 {
2419 for (unsigned int i = 0; i < count - 1; i++)
2420 DF_MWS_NEXT ((*old_vec)[i]) = (*old_vec)[i + 1];
2421 DF_MWS_NEXT ((*old_vec)[count - 1]) = 0;
2422 return (*old_vec)[0];
2423 }
2424 else
2425 return 0;
2426 }
2427
2428
2429 /* Add a chain of df_refs to appropriate ref chain/reg_info/ref_info
2430 chains and update other necessary information. */
2431
2432 static void
2433 df_refs_add_to_chains (struct df_collection_rec *collection_rec,
2434 basic_block bb, rtx_insn *insn, unsigned int flags)
2435 {
2436 if (insn)
2437 {
2438 struct df_insn_info *insn_rec = DF_INSN_INFO_GET (insn);
2439 /* If there is a vector in the collection rec, add it to the
2440 insn. A null rec is a signal that the caller will handle the
2441 chain specially. */
2442 if (flags & copy_defs)
2443 {
2444 gcc_checking_assert (!insn_rec->defs);
2445 insn_rec->defs
2446 = df_install_refs (bb, &collection_rec->def_vec,
2447 df->def_regs,
2448 &df->def_info, false);
2449 }
2450 if (flags & copy_uses)
2451 {
2452 gcc_checking_assert (!insn_rec->uses);
2453 insn_rec->uses
2454 = df_install_refs (bb, &collection_rec->use_vec,
2455 df->use_regs,
2456 &df->use_info, false);
2457 }
2458 if (flags & copy_eq_uses)
2459 {
2460 gcc_checking_assert (!insn_rec->eq_uses);
2461 insn_rec->eq_uses
2462 = df_install_refs (bb, &collection_rec->eq_use_vec,
2463 df->eq_use_regs,
2464 &df->use_info, true);
2465 }
2466 if (flags & copy_mw)
2467 {
2468 gcc_checking_assert (!insn_rec->mw_hardregs);
2469 insn_rec->mw_hardregs
2470 = df_install_mws (&collection_rec->mw_vec);
2471 }
2472 }
2473 else
2474 {
2475 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb->index);
2476
2477 gcc_checking_assert (!bb_info->artificial_defs);
2478 bb_info->artificial_defs
2479 = df_install_refs (bb, &collection_rec->def_vec,
2480 df->def_regs,
2481 &df->def_info, false);
2482 gcc_checking_assert (!bb_info->artificial_uses);
2483 bb_info->artificial_uses
2484 = df_install_refs (bb, &collection_rec->use_vec,
2485 df->use_regs,
2486 &df->use_info, false);
2487 }
2488 }
2489
2490
2491 /* Allocate a ref and initialize its fields. */
2492
2493 static df_ref
2494 df_ref_create_structure (enum df_ref_class cl,
2495 struct df_collection_rec *collection_rec,
2496 rtx reg, rtx *loc,
2497 basic_block bb, struct df_insn_info *info,
2498 enum df_ref_type ref_type,
2499 int ref_flags)
2500 {
2501 df_ref this_ref = NULL;
2502 int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
2503 struct df_scan_problem_data *problem_data
2504 = (struct df_scan_problem_data *) df_scan->problem_data;
2505
2506 switch (cl)
2507 {
2508 case DF_REF_BASE:
2509 this_ref = (df_ref) (problem_data->ref_base_pool->allocate ());
2510 gcc_checking_assert (loc == NULL);
2511 break;
2512
2513 case DF_REF_ARTIFICIAL:
2514 this_ref = (df_ref) (problem_data->ref_artificial_pool->allocate ());
2515 this_ref->artificial_ref.bb = bb;
2516 gcc_checking_assert (loc == NULL);
2517 break;
2518
2519 case DF_REF_REGULAR:
2520 this_ref = (df_ref) (problem_data->ref_regular_pool->allocate ());
2521 this_ref->regular_ref.loc = loc;
2522 gcc_checking_assert (loc);
2523 break;
2524 }
2525
2526 DF_REF_CLASS (this_ref) = cl;
2527 DF_REF_ID (this_ref) = -1;
2528 DF_REF_REG (this_ref) = reg;
2529 DF_REF_REGNO (this_ref) = regno;
2530 DF_REF_TYPE (this_ref) = ref_type;
2531 DF_REF_INSN_INFO (this_ref) = info;
2532 DF_REF_CHAIN (this_ref) = NULL;
2533 DF_REF_FLAGS (this_ref) = ref_flags;
2534 DF_REF_NEXT_REG (this_ref) = NULL;
2535 DF_REF_PREV_REG (this_ref) = NULL;
2536 DF_REF_ORDER (this_ref) = df->ref_order++;
2537
2538 /* We need to clear this bit because fwprop, and in the future
2539 possibly other optimizations sometimes create new refs using ond
2540 refs as the model. */
2541 DF_REF_FLAGS_CLEAR (this_ref, DF_HARD_REG_LIVE);
2542
2543 /* See if this ref needs to have DF_HARD_REG_LIVE bit set. */
2544 if (regno < FIRST_PSEUDO_REGISTER
2545 && !DF_REF_IS_ARTIFICIAL (this_ref)
2546 && !DEBUG_INSN_P (DF_REF_INSN (this_ref)))
2547 {
2548 if (DF_REF_REG_DEF_P (this_ref))
2549 {
2550 if (!DF_REF_FLAGS_IS_SET (this_ref, DF_REF_MAY_CLOBBER))
2551 DF_REF_FLAGS_SET (this_ref, DF_HARD_REG_LIVE);
2552 }
2553 else if (!(TEST_HARD_REG_BIT (elim_reg_set, regno)
2554 && (regno == FRAME_POINTER_REGNUM
2555 || regno == ARG_POINTER_REGNUM)))
2556 DF_REF_FLAGS_SET (this_ref, DF_HARD_REG_LIVE);
2557 }
2558
2559 if (collection_rec)
2560 {
2561 if (DF_REF_REG_DEF_P (this_ref))
2562 collection_rec->def_vec.safe_push (this_ref);
2563 else if (DF_REF_FLAGS (this_ref) & DF_REF_IN_NOTE)
2564 collection_rec->eq_use_vec.safe_push (this_ref);
2565 else
2566 collection_rec->use_vec.safe_push (this_ref);
2567 }
2568 else
2569 df_install_ref_incremental (this_ref);
2570
2571 return this_ref;
2572 }
2573
2574
2575 /* Create new references of type DF_REF_TYPE for each part of register REG
2576 at address LOC within INSN of BB. */
2577
2578
2579 static void
2580 df_ref_record (enum df_ref_class cl,
2581 struct df_collection_rec *collection_rec,
2582 rtx reg, rtx *loc,
2583 basic_block bb, struct df_insn_info *insn_info,
2584 enum df_ref_type ref_type,
2585 int ref_flags)
2586 {
2587 unsigned int regno;
2588
2589 gcc_checking_assert (REG_P (reg) || GET_CODE (reg) == SUBREG);
2590
2591 regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
2592 if (regno < FIRST_PSEUDO_REGISTER)
2593 {
2594 struct df_mw_hardreg *hardreg = NULL;
2595 struct df_scan_problem_data *problem_data
2596 = (struct df_scan_problem_data *) df_scan->problem_data;
2597 unsigned int i;
2598 unsigned int endregno;
2599 df_ref ref;
2600
2601 if (GET_CODE (reg) == SUBREG)
2602 {
2603 regno += subreg_regno_offset (regno, GET_MODE (SUBREG_REG (reg)),
2604 SUBREG_BYTE (reg), GET_MODE (reg));
2605 endregno = regno + subreg_nregs (reg);
2606 }
2607 else
2608 endregno = END_REGNO (reg);
2609
2610 /* If this is a multiword hardreg, we create some extra
2611 datastructures that will enable us to easily build REG_DEAD
2612 and REG_UNUSED notes. */
2613 if (collection_rec
2614 && (endregno != regno + 1) && insn_info)
2615 {
2616 /* Sets to a subreg of a multiword register are partial.
2617 Sets to a non-subreg of a multiword register are not. */
2618 if (GET_CODE (reg) == SUBREG)
2619 ref_flags |= DF_REF_PARTIAL;
2620 ref_flags |= DF_REF_MW_HARDREG;
2621
2622 hardreg = problem_data->mw_reg_pool->allocate ();
2623 hardreg->type = ref_type;
2624 hardreg->flags = ref_flags;
2625 hardreg->mw_reg = reg;
2626 hardreg->start_regno = regno;
2627 hardreg->end_regno = endregno - 1;
2628 hardreg->mw_order = df->ref_order++;
2629 collection_rec->mw_vec.safe_push (hardreg);
2630 }
2631
2632 for (i = regno; i < endregno; i++)
2633 {
2634 ref = df_ref_create_structure (cl, collection_rec, regno_reg_rtx[i], loc,
2635 bb, insn_info, ref_type, ref_flags);
2636
2637 gcc_assert (ORIGINAL_REGNO (DF_REF_REG (ref)) == i);
2638 }
2639 }
2640 else
2641 {
2642 df_ref_create_structure (cl, collection_rec, reg, loc, bb, insn_info,
2643 ref_type, ref_flags);
2644 }
2645 }
2646
2647
2648 /* A set to a non-paradoxical SUBREG for which the number of word_mode units
2649 covered by the outer mode is smaller than that covered by the inner mode,
2650 is a read-modify-write operation.
2651 This function returns true iff the SUBREG X is such a SUBREG. */
2652
2653 bool
2654 df_read_modify_subreg_p (rtx x)
2655 {
2656 unsigned int isize, osize;
2657 if (GET_CODE (x) != SUBREG)
2658 return false;
2659 isize = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
2660 osize = GET_MODE_SIZE (GET_MODE (x));
2661 return isize > osize
2662 && isize > REGMODE_NATURAL_SIZE (GET_MODE (SUBREG_REG (x)));
2663 }
2664
2665
2666 /* Process all the registers defined in the rtx pointed by LOC.
2667 Autoincrement/decrement definitions will be picked up by df_uses_record.
2668 Any change here has to be matched in df_find_hard_reg_defs_1. */
2669
2670 static void
2671 df_def_record_1 (struct df_collection_rec *collection_rec,
2672 rtx *loc, basic_block bb, struct df_insn_info *insn_info,
2673 int flags)
2674 {
2675 rtx dst = *loc;
2676
2677 /* It is legal to have a set destination be a parallel. */
2678 if (GET_CODE (dst) == PARALLEL)
2679 {
2680 int i;
2681 for (i = XVECLEN (dst, 0) - 1; i >= 0; i--)
2682 {
2683 rtx temp = XVECEXP (dst, 0, i);
2684 gcc_assert (GET_CODE (temp) == EXPR_LIST);
2685 df_def_record_1 (collection_rec, &XEXP (temp, 0),
2686 bb, insn_info, flags);
2687 }
2688 return;
2689 }
2690
2691 if (GET_CODE (dst) == STRICT_LOW_PART)
2692 {
2693 flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_STRICT_LOW_PART;
2694
2695 loc = &XEXP (dst, 0);
2696 dst = *loc;
2697 }
2698
2699 if (GET_CODE (dst) == ZERO_EXTRACT)
2700 {
2701 flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_ZERO_EXTRACT;
2702
2703 loc = &XEXP (dst, 0);
2704 dst = *loc;
2705 }
2706
2707 /* At this point if we do not have a reg or a subreg, just return. */
2708 if (REG_P (dst))
2709 {
2710 df_ref_record (DF_REF_REGULAR, collection_rec,
2711 dst, loc, bb, insn_info, DF_REF_REG_DEF, flags);
2712
2713 /* We want to keep sp alive everywhere - by making all
2714 writes to sp also use of sp. */
2715 if (REGNO (dst) == STACK_POINTER_REGNUM)
2716 df_ref_record (DF_REF_BASE, collection_rec,
2717 dst, NULL, bb, insn_info, DF_REF_REG_USE, flags);
2718 }
2719 else if (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst)))
2720 {
2721 if (df_read_modify_subreg_p (dst))
2722 flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL;
2723
2724 flags |= DF_REF_SUBREG;
2725
2726 df_ref_record (DF_REF_REGULAR, collection_rec,
2727 dst, loc, bb, insn_info, DF_REF_REG_DEF, flags);
2728 }
2729 }
2730
2731
2732 /* Process all the registers defined in the pattern rtx, X. Any change
2733 here has to be matched in df_find_hard_reg_defs. */
2734
2735 static void
2736 df_defs_record (struct df_collection_rec *collection_rec,
2737 rtx x, basic_block bb, struct df_insn_info *insn_info,
2738 int flags)
2739 {
2740 RTX_CODE code = GET_CODE (x);
2741 int i;
2742
2743 switch (code)
2744 {
2745 case SET:
2746 df_def_record_1 (collection_rec, &SET_DEST (x), bb, insn_info, flags);
2747 break;
2748
2749 case CLOBBER:
2750 flags |= DF_REF_MUST_CLOBBER;
2751 df_def_record_1 (collection_rec, &XEXP (x, 0), bb, insn_info, flags);
2752 break;
2753
2754 case COND_EXEC:
2755 df_defs_record (collection_rec, COND_EXEC_CODE (x),
2756 bb, insn_info, DF_REF_CONDITIONAL);
2757 break;
2758
2759 case PARALLEL:
2760 for (i = 0; i < XVECLEN (x, 0); i++)
2761 df_defs_record (collection_rec, XVECEXP (x, 0, i),
2762 bb, insn_info, flags);
2763 break;
2764 default:
2765 /* No DEFs to record in other cases */
2766 break;
2767 }
2768 }
2769
2770 /* Set bits in *DEFS for hard registers found in the rtx DST, which is the
2771 destination of a set or clobber. This has to match the logic in
2772 df_defs_record_1. */
2773
2774 static void
2775 df_find_hard_reg_defs_1 (rtx dst, HARD_REG_SET *defs)
2776 {
2777 /* It is legal to have a set destination be a parallel. */
2778 if (GET_CODE (dst) == PARALLEL)
2779 {
2780 int i;
2781 for (i = XVECLEN (dst, 0) - 1; i >= 0; i--)
2782 {
2783 rtx temp = XVECEXP (dst, 0, i);
2784 gcc_assert (GET_CODE (temp) == EXPR_LIST);
2785 df_find_hard_reg_defs_1 (XEXP (temp, 0), defs);
2786 }
2787 return;
2788 }
2789
2790 if (GET_CODE (dst) == STRICT_LOW_PART)
2791 dst = XEXP (dst, 0);
2792
2793 if (GET_CODE (dst) == ZERO_EXTRACT)
2794 dst = XEXP (dst, 0);
2795
2796 /* At this point if we do not have a reg or a subreg, just return. */
2797 if (REG_P (dst) && HARD_REGISTER_P (dst))
2798 SET_HARD_REG_BIT (*defs, REGNO (dst));
2799 else if (GET_CODE (dst) == SUBREG
2800 && REG_P (SUBREG_REG (dst)) && HARD_REGISTER_P (dst))
2801 SET_HARD_REG_BIT (*defs, REGNO (SUBREG_REG (dst)));
2802 }
2803
2804 /* Set bits in *DEFS for hard registers defined in the pattern X. This
2805 has to match the logic in df_defs_record. */
2806
2807 static void
2808 df_find_hard_reg_defs (rtx x, HARD_REG_SET *defs)
2809 {
2810 RTX_CODE code = GET_CODE (x);
2811 int i;
2812
2813 switch (code)
2814 {
2815 case SET:
2816 df_find_hard_reg_defs_1 (SET_DEST (x), defs);
2817 break;
2818
2819 case CLOBBER:
2820 df_find_hard_reg_defs_1 (XEXP (x, 0), defs);
2821 break;
2822
2823 case COND_EXEC:
2824 df_find_hard_reg_defs (COND_EXEC_CODE (x), defs);
2825 break;
2826
2827 case PARALLEL:
2828 for (i = 0; i < XVECLEN (x, 0); i++)
2829 df_find_hard_reg_defs (XVECEXP (x, 0, i), defs);
2830 break;
2831 default:
2832 /* No DEFs to record in other cases */
2833 break;
2834 }
2835 }
2836
2837
2838 /* Process all the registers used in the rtx at address LOC. */
2839
2840 static void
2841 df_uses_record (struct df_collection_rec *collection_rec,
2842 rtx *loc, enum df_ref_type ref_type,
2843 basic_block bb, struct df_insn_info *insn_info,
2844 int flags)
2845 {
2846 RTX_CODE code;
2847 rtx x;
2848
2849 retry:
2850 x = *loc;
2851 if (!x)
2852 return;
2853 code = GET_CODE (x);
2854 switch (code)
2855 {
2856 case LABEL_REF:
2857 case SYMBOL_REF:
2858 case CONST:
2859 CASE_CONST_ANY:
2860 case PC:
2861 case CC0:
2862 case ADDR_VEC:
2863 case ADDR_DIFF_VEC:
2864 return;
2865
2866 case CLOBBER:
2867 /* If we are clobbering a MEM, mark any registers inside the address
2868 as being used. */
2869 if (MEM_P (XEXP (x, 0)))
2870 df_uses_record (collection_rec,
2871 &XEXP (XEXP (x, 0), 0),
2872 DF_REF_REG_MEM_STORE,
2873 bb, insn_info,
2874 flags);
2875
2876 /* If we're clobbering a REG then we have a def so ignore. */
2877 return;
2878
2879 case MEM:
2880 df_uses_record (collection_rec,
2881 &XEXP (x, 0), DF_REF_REG_MEM_LOAD,
2882 bb, insn_info, flags & DF_REF_IN_NOTE);
2883 return;
2884
2885 case SUBREG:
2886 /* While we're here, optimize this case. */
2887 flags |= DF_REF_PARTIAL;
2888 /* In case the SUBREG is not of a REG, do not optimize. */
2889 if (!REG_P (SUBREG_REG (x)))
2890 {
2891 loc = &SUBREG_REG (x);
2892 df_uses_record (collection_rec, loc, ref_type, bb, insn_info, flags);
2893 return;
2894 }
2895 /* ... Fall through ... */
2896
2897 case REG:
2898 df_ref_record (DF_REF_REGULAR, collection_rec,
2899 x, loc, bb, insn_info,
2900 ref_type, flags);
2901 return;
2902
2903 case SIGN_EXTRACT:
2904 case ZERO_EXTRACT:
2905 {
2906 df_uses_record (collection_rec,
2907 &XEXP (x, 1), ref_type, bb, insn_info, flags);
2908 df_uses_record (collection_rec,
2909 &XEXP (x, 2), ref_type, bb, insn_info, flags);
2910
2911 /* If the parameters to the zero or sign extract are
2912 constants, strip them off and recurse, otherwise there is
2913 no information that we can gain from this operation. */
2914 if (code == ZERO_EXTRACT)
2915 flags |= DF_REF_ZERO_EXTRACT;
2916 else
2917 flags |= DF_REF_SIGN_EXTRACT;
2918
2919 df_uses_record (collection_rec,
2920 &XEXP (x, 0), ref_type, bb, insn_info, flags);
2921 return;
2922 }
2923 break;
2924
2925 case SET:
2926 {
2927 rtx dst = SET_DEST (x);
2928 gcc_assert (!(flags & DF_REF_IN_NOTE));
2929 df_uses_record (collection_rec,
2930 &SET_SRC (x), DF_REF_REG_USE, bb, insn_info, flags);
2931
2932 switch (GET_CODE (dst))
2933 {
2934 case SUBREG:
2935 if (df_read_modify_subreg_p (dst))
2936 {
2937 df_uses_record (collection_rec, &SUBREG_REG (dst),
2938 DF_REF_REG_USE, bb, insn_info,
2939 flags | DF_REF_READ_WRITE | DF_REF_SUBREG);
2940 break;
2941 }
2942 /* Fall through. */
2943 case REG:
2944 case PARALLEL:
2945 case SCRATCH:
2946 case PC:
2947 case CC0:
2948 break;
2949 case MEM:
2950 df_uses_record (collection_rec, &XEXP (dst, 0),
2951 DF_REF_REG_MEM_STORE, bb, insn_info, flags);
2952 break;
2953 case STRICT_LOW_PART:
2954 {
2955 rtx *temp = &XEXP (dst, 0);
2956 /* A strict_low_part uses the whole REG and not just the
2957 SUBREG. */
2958 dst = XEXP (dst, 0);
2959 df_uses_record (collection_rec,
2960 (GET_CODE (dst) == SUBREG) ? &SUBREG_REG (dst) : temp,
2961 DF_REF_REG_USE, bb, insn_info,
2962 DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART);
2963 }
2964 break;
2965 case ZERO_EXTRACT:
2966 {
2967 df_uses_record (collection_rec, &XEXP (dst, 1),
2968 DF_REF_REG_USE, bb, insn_info, flags);
2969 df_uses_record (collection_rec, &XEXP (dst, 2),
2970 DF_REF_REG_USE, bb, insn_info, flags);
2971 if (GET_CODE (XEXP (dst,0)) == MEM)
2972 df_uses_record (collection_rec, &XEXP (dst, 0),
2973 DF_REF_REG_USE, bb, insn_info,
2974 flags);
2975 else
2976 df_uses_record (collection_rec, &XEXP (dst, 0),
2977 DF_REF_REG_USE, bb, insn_info,
2978 DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT);
2979 }
2980 break;
2981
2982 default:
2983 gcc_unreachable ();
2984 }
2985 return;
2986 }
2987
2988 case RETURN:
2989 case SIMPLE_RETURN:
2990 break;
2991
2992 case ASM_OPERANDS:
2993 case UNSPEC_VOLATILE:
2994 case TRAP_IF:
2995 case ASM_INPUT:
2996 {
2997 /* Traditional and volatile asm instructions must be
2998 considered to use and clobber all hard registers, all
2999 pseudo-registers and all of memory. So must TRAP_IF and
3000 UNSPEC_VOLATILE operations.
3001
3002 Consider for instance a volatile asm that changes the fpu
3003 rounding mode. An insn should not be moved across this
3004 even if it only uses pseudo-regs because it might give an
3005 incorrectly rounded result.
3006
3007 However, flow.c's liveness computation did *not* do this,
3008 giving the reasoning as " ?!? Unfortunately, marking all
3009 hard registers as live causes massive problems for the
3010 register allocator and marking all pseudos as live creates
3011 mountains of uninitialized variable warnings."
3012
3013 In order to maintain the status quo with regard to liveness
3014 and uses, we do what flow.c did and just mark any regs we
3015 can find in ASM_OPERANDS as used. In global asm insns are
3016 scanned and regs_asm_clobbered is filled out.
3017
3018 For all ASM_OPERANDS, we must traverse the vector of input
3019 operands. We can not just fall through here since then we
3020 would be confused by the ASM_INPUT rtx inside ASM_OPERANDS,
3021 which do not indicate traditional asms unlike their normal
3022 usage. */
3023 if (code == ASM_OPERANDS)
3024 {
3025 int j;
3026
3027 for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
3028 df_uses_record (collection_rec, &ASM_OPERANDS_INPUT (x, j),
3029 DF_REF_REG_USE, bb, insn_info, flags);
3030 return;
3031 }
3032 break;
3033 }
3034
3035 case VAR_LOCATION:
3036 df_uses_record (collection_rec,
3037 &PAT_VAR_LOCATION_LOC (x),
3038 DF_REF_REG_USE, bb, insn_info, flags);
3039 return;
3040
3041 case PRE_DEC:
3042 case POST_DEC:
3043 case PRE_INC:
3044 case POST_INC:
3045 case PRE_MODIFY:
3046 case POST_MODIFY:
3047 gcc_assert (!DEBUG_INSN_P (insn_info->insn));
3048 /* Catch the def of the register being modified. */
3049 df_ref_record (DF_REF_REGULAR, collection_rec, XEXP (x, 0), &XEXP (x, 0),
3050 bb, insn_info,
3051 DF_REF_REG_DEF,
3052 flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY);
3053
3054 /* ... Fall through to handle uses ... */
3055
3056 default:
3057 break;
3058 }
3059
3060 /* Recursively scan the operands of this expression. */
3061 {
3062 const char *fmt = GET_RTX_FORMAT (code);
3063 int i;
3064
3065 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3066 {
3067 if (fmt[i] == 'e')
3068 {
3069 /* Tail recursive case: save a function call level. */
3070 if (i == 0)
3071 {
3072 loc = &XEXP (x, 0);
3073 goto retry;
3074 }
3075 df_uses_record (collection_rec, &XEXP (x, i), ref_type,
3076 bb, insn_info, flags);
3077 }
3078 else if (fmt[i] == 'E')
3079 {
3080 int j;
3081 for (j = 0; j < XVECLEN (x, i); j++)
3082 df_uses_record (collection_rec,
3083 &XVECEXP (x, i, j), ref_type,
3084 bb, insn_info, flags);
3085 }
3086 }
3087 }
3088
3089 return;
3090 }
3091
3092
3093 /* For all DF_REF_CONDITIONAL defs, add a corresponding uses. */
3094
3095 static void
3096 df_get_conditional_uses (struct df_collection_rec *collection_rec)
3097 {
3098 unsigned int ix;
3099 df_ref ref;
3100
3101 FOR_EACH_VEC_ELT (collection_rec->def_vec, ix, ref)
3102 {
3103 if (DF_REF_FLAGS_IS_SET (ref, DF_REF_CONDITIONAL))
3104 {
3105 df_ref use;
3106
3107 use = df_ref_create_structure (DF_REF_CLASS (ref), collection_rec, DF_REF_REG (ref),
3108 DF_REF_LOC (ref), DF_REF_BB (ref),
3109 DF_REF_INSN_INFO (ref), DF_REF_REG_USE,
3110 DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL);
3111 DF_REF_REGNO (use) = DF_REF_REGNO (ref);
3112 }
3113 }
3114 }
3115
3116
3117 /* Get call's extra defs and uses (track caller-saved registers). */
3118
3119 static void
3120 df_get_call_refs (struct df_collection_rec *collection_rec,
3121 basic_block bb,
3122 struct df_insn_info *insn_info,
3123 int flags)
3124 {
3125 rtx note;
3126 bool is_sibling_call;
3127 unsigned int i;
3128 HARD_REG_SET defs_generated;
3129 HARD_REG_SET fn_reg_set_usage;
3130
3131 CLEAR_HARD_REG_SET (defs_generated);
3132 df_find_hard_reg_defs (PATTERN (insn_info->insn), &defs_generated);
3133 is_sibling_call = SIBLING_CALL_P (insn_info->insn);
3134 get_call_reg_set_usage (insn_info->insn, &fn_reg_set_usage,
3135 regs_invalidated_by_call);
3136
3137 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3138 {
3139 if (i == STACK_POINTER_REGNUM)
3140 /* The stack ptr is used (honorarily) by a CALL insn. */
3141 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
3142 NULL, bb, insn_info, DF_REF_REG_USE,
3143 DF_REF_CALL_STACK_USAGE | flags);
3144 else if (global_regs[i])
3145 {
3146 /* Calls to const functions cannot access any global registers and
3147 calls to pure functions cannot set them. All other calls may
3148 reference any of the global registers, so they are recorded as
3149 used. */
3150 if (!RTL_CONST_CALL_P (insn_info->insn))
3151 {
3152 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
3153 NULL, bb, insn_info, DF_REF_REG_USE, flags);
3154 if (!RTL_PURE_CALL_P (insn_info->insn))
3155 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
3156 NULL, bb, insn_info, DF_REF_REG_DEF, flags);
3157 }
3158 }
3159 else if (TEST_HARD_REG_BIT (fn_reg_set_usage, i)
3160 /* no clobbers for regs that are the result of the call */
3161 && !TEST_HARD_REG_BIT (defs_generated, i)
3162 && (!is_sibling_call
3163 || !bitmap_bit_p (df->exit_block_uses, i)
3164 || refers_to_regno_p (i, crtl->return_rtx)))
3165 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
3166 NULL, bb, insn_info, DF_REF_REG_DEF,
3167 DF_REF_MAY_CLOBBER | flags);
3168 }
3169
3170 /* Record the registers used to pass arguments, and explicitly
3171 noted as clobbered. */
3172 for (note = CALL_INSN_FUNCTION_USAGE (insn_info->insn); note;
3173 note = XEXP (note, 1))
3174 {
3175 if (GET_CODE (XEXP (note, 0)) == USE)
3176 df_uses_record (collection_rec, &XEXP (XEXP (note, 0), 0),
3177 DF_REF_REG_USE, bb, insn_info, flags);
3178 else if (GET_CODE (XEXP (note, 0)) == CLOBBER)
3179 {
3180 if (REG_P (XEXP (XEXP (note, 0), 0)))
3181 {
3182 unsigned int regno = REGNO (XEXP (XEXP (note, 0), 0));
3183 if (!TEST_HARD_REG_BIT (defs_generated, regno))
3184 df_defs_record (collection_rec, XEXP (note, 0), bb,
3185 insn_info, flags);
3186 }
3187 else
3188 df_uses_record (collection_rec, &XEXP (note, 0),
3189 DF_REF_REG_USE, bb, insn_info, flags);
3190 }
3191 }
3192
3193 return;
3194 }
3195
3196 /* Collect all refs in the INSN. This function is free of any
3197 side-effect - it will create and return a lists of df_ref's in the
3198 COLLECTION_REC without putting those refs into existing ref chains
3199 and reg chains. */
3200
3201 static void
3202 df_insn_refs_collect (struct df_collection_rec *collection_rec,
3203 basic_block bb, struct df_insn_info *insn_info)
3204 {
3205 rtx note;
3206 bool is_cond_exec = (GET_CODE (PATTERN (insn_info->insn)) == COND_EXEC);
3207
3208 /* Clear out the collection record. */
3209 collection_rec->def_vec.truncate (0);
3210 collection_rec->use_vec.truncate (0);
3211 collection_rec->eq_use_vec.truncate (0);
3212 collection_rec->mw_vec.truncate (0);
3213
3214 /* Process REG_EQUIV/REG_EQUAL notes. */
3215 for (note = REG_NOTES (insn_info->insn); note;
3216 note = XEXP (note, 1))
3217 {
3218 switch (REG_NOTE_KIND (note))
3219 {
3220 case REG_EQUIV:
3221 case REG_EQUAL:
3222 df_uses_record (collection_rec,
3223 &XEXP (note, 0), DF_REF_REG_USE,
3224 bb, insn_info, DF_REF_IN_NOTE);
3225 break;
3226 case REG_NON_LOCAL_GOTO:
3227 /* The frame ptr is used by a non-local goto. */
3228 df_ref_record (DF_REF_BASE, collection_rec,
3229 regno_reg_rtx[FRAME_POINTER_REGNUM],
3230 NULL, bb, insn_info,
3231 DF_REF_REG_USE, 0);
3232 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
3233 df_ref_record (DF_REF_BASE, collection_rec,
3234 regno_reg_rtx[HARD_FRAME_POINTER_REGNUM],
3235 NULL, bb, insn_info,
3236 DF_REF_REG_USE, 0);
3237 break;
3238 default:
3239 break;
3240 }
3241 }
3242
3243 /* For CALL_INSNs, first record DF_REF_BASE register defs, as well as
3244 uses from CALL_INSN_FUNCTION_USAGE. */
3245 if (CALL_P (insn_info->insn))
3246 df_get_call_refs (collection_rec, bb, insn_info,
3247 (is_cond_exec) ? DF_REF_CONDITIONAL : 0);
3248
3249 /* Record other defs. These should be mostly for DF_REF_REGULAR, so
3250 that a qsort on the defs is unnecessary in most cases. */
3251 df_defs_record (collection_rec,
3252 PATTERN (insn_info->insn), bb, insn_info, 0);
3253
3254 /* Record the register uses. */
3255 df_uses_record (collection_rec,
3256 &PATTERN (insn_info->insn), DF_REF_REG_USE, bb, insn_info, 0);
3257
3258 /* DF_REF_CONDITIONAL needs corresponding USES. */
3259 if (is_cond_exec)
3260 df_get_conditional_uses (collection_rec);
3261
3262 df_canonize_collection_rec (collection_rec);
3263 }
3264
3265 /* Recompute the luids for the insns in BB. */
3266
3267 void
3268 df_recompute_luids (basic_block bb)
3269 {
3270 rtx_insn *insn;
3271 int luid = 0;
3272
3273 df_grow_insn_info ();
3274
3275 /* Scan the block an insn at a time from beginning to end. */
3276 FOR_BB_INSNS (bb, insn)
3277 {
3278 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
3279 /* Inserting labels does not always trigger the incremental
3280 rescanning. */
3281 if (!insn_info)
3282 {
3283 gcc_assert (!INSN_P (insn));
3284 insn_info = df_insn_create_insn_record (insn);
3285 }
3286
3287 DF_INSN_INFO_LUID (insn_info) = luid;
3288 if (INSN_P (insn))
3289 luid++;
3290 }
3291 }
3292
3293
3294 /* Collect all artificial refs at the block level for BB and add them
3295 to COLLECTION_REC. */
3296
3297 static void
3298 df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb)
3299 {
3300 collection_rec->def_vec.truncate (0);
3301 collection_rec->use_vec.truncate (0);
3302 collection_rec->eq_use_vec.truncate (0);
3303 collection_rec->mw_vec.truncate (0);
3304
3305 if (bb->index == ENTRY_BLOCK)
3306 {
3307 df_entry_block_defs_collect (collection_rec, df->entry_block_defs);
3308 return;
3309 }
3310 else if (bb->index == EXIT_BLOCK)
3311 {
3312 df_exit_block_uses_collect (collection_rec, df->exit_block_uses);
3313 return;
3314 }
3315
3316 if (bb_has_eh_pred (bb))
3317 {
3318 unsigned int i;
3319 /* Mark the registers that will contain data for the handler. */
3320 for (i = 0; ; ++i)
3321 {
3322 unsigned regno = EH_RETURN_DATA_REGNO (i);
3323 if (regno == INVALID_REGNUM)
3324 break;
3325 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
3326 bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP);
3327 }
3328 }
3329
3330 /* Add the hard_frame_pointer if this block is the target of a
3331 non-local goto. */
3332 if (bb->flags & BB_NON_LOCAL_GOTO_TARGET)
3333 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, hard_frame_pointer_rtx, NULL,
3334 bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP);
3335
3336 /* Add the artificial uses. */
3337 if (bb->index >= NUM_FIXED_BLOCKS)
3338 {
3339 bitmap_iterator bi;
3340 unsigned int regno;
3341 bitmap au = bb_has_eh_pred (bb)
3342 ? &df->eh_block_artificial_uses
3343 : &df->regular_block_artificial_uses;
3344
3345 EXECUTE_IF_SET_IN_BITMAP (au, 0, regno, bi)
3346 {
3347 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
3348 bb, NULL, DF_REF_REG_USE, 0);
3349 }
3350 }
3351
3352 df_canonize_collection_rec (collection_rec);
3353 }
3354
3355
3356 /* Record all the refs within the basic block BB_INDEX and scan the instructions if SCAN_INSNS. */
3357
3358 void
3359 df_bb_refs_record (int bb_index, bool scan_insns)
3360 {
3361 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
3362 rtx_insn *insn;
3363 int luid = 0;
3364
3365 if (!df)
3366 return;
3367
3368 df_collection_rec collection_rec;
3369 df_grow_bb_info (df_scan);
3370 if (scan_insns)
3371 /* Scan the block an insn at a time from beginning to end. */
3372 FOR_BB_INSNS (bb, insn)
3373 {
3374 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
3375 gcc_assert (!insn_info);
3376
3377 insn_info = df_insn_create_insn_record (insn);
3378 if (INSN_P (insn))
3379 {
3380 /* Record refs within INSN. */
3381 DF_INSN_INFO_LUID (insn_info) = luid++;
3382 df_insn_refs_collect (&collection_rec, bb, DF_INSN_INFO_GET (insn));
3383 df_refs_add_to_chains (&collection_rec, bb, insn, copy_all);
3384 }
3385 DF_INSN_INFO_LUID (insn_info) = luid;
3386 }
3387
3388 /* Other block level artificial refs */
3389 df_bb_refs_collect (&collection_rec, bb);
3390 df_refs_add_to_chains (&collection_rec, bb, NULL, copy_all);
3391
3392 /* Now that the block has been processed, set the block as dirty so
3393 LR and LIVE will get it processed. */
3394 df_set_bb_dirty (bb);
3395 }
3396
3397
3398 /* Get the artificial use set for a regular (i.e. non-exit/non-entry)
3399 block. */
3400
3401 static void
3402 df_get_regular_block_artificial_uses (bitmap regular_block_artificial_uses)
3403 {
3404 #ifdef EH_USES
3405 unsigned int i;
3406 #endif
3407
3408 bitmap_clear (regular_block_artificial_uses);
3409
3410 if (reload_completed)
3411 {
3412 if (frame_pointer_needed)
3413 bitmap_set_bit (regular_block_artificial_uses, HARD_FRAME_POINTER_REGNUM);
3414 }
3415 else
3416 /* Before reload, there are a few registers that must be forced
3417 live everywhere -- which might not already be the case for
3418 blocks within infinite loops. */
3419 {
3420 unsigned int picreg = PIC_OFFSET_TABLE_REGNUM;
3421
3422 /* Any reference to any pseudo before reload is a potential
3423 reference of the frame pointer. */
3424 bitmap_set_bit (regular_block_artificial_uses, FRAME_POINTER_REGNUM);
3425
3426 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
3427 bitmap_set_bit (regular_block_artificial_uses,
3428 HARD_FRAME_POINTER_REGNUM);
3429
3430 /* Pseudos with argument area equivalences may require
3431 reloading via the argument pointer. */
3432 if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3433 && fixed_regs[ARG_POINTER_REGNUM])
3434 bitmap_set_bit (regular_block_artificial_uses, ARG_POINTER_REGNUM);
3435
3436 /* Any constant, or pseudo with constant equivalences, may
3437 require reloading from memory using the pic register. */
3438 if (picreg != INVALID_REGNUM
3439 && fixed_regs[picreg])
3440 bitmap_set_bit (regular_block_artificial_uses, picreg);
3441 }
3442 /* The all-important stack pointer must always be live. */
3443 bitmap_set_bit (regular_block_artificial_uses, STACK_POINTER_REGNUM);
3444
3445 #ifdef EH_USES
3446 /* EH_USES registers are used:
3447 1) at all insns that might throw (calls or with -fnon-call-exceptions
3448 trapping insns)
3449 2) in all EH edges
3450 3) to support backtraces and/or debugging, anywhere between their
3451 initialization and where they the saved registers are restored
3452 from them, including the cases where we don't reach the epilogue
3453 (noreturn call or infinite loop). */
3454 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3455 if (EH_USES (i))
3456 bitmap_set_bit (regular_block_artificial_uses, i);
3457 #endif
3458 }
3459
3460
3461 /* Get the artificial use set for an eh block. */
3462
3463 static void
3464 df_get_eh_block_artificial_uses (bitmap eh_block_artificial_uses)
3465 {
3466 bitmap_clear (eh_block_artificial_uses);
3467
3468 /* The following code (down through the arg_pointer setting APPEARS
3469 to be necessary because there is nothing that actually
3470 describes what the exception handling code may actually need
3471 to keep alive. */
3472 if (reload_completed)
3473 {
3474 if (frame_pointer_needed)
3475 {
3476 bitmap_set_bit (eh_block_artificial_uses, FRAME_POINTER_REGNUM);
3477 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER)
3478 bitmap_set_bit (eh_block_artificial_uses,
3479 HARD_FRAME_POINTER_REGNUM);
3480 }
3481 if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3482 && fixed_regs[ARG_POINTER_REGNUM])
3483 bitmap_set_bit (eh_block_artificial_uses, ARG_POINTER_REGNUM);
3484 }
3485 }
3486
3487
3488 \f
3489 /*----------------------------------------------------------------------------
3490 Specialized hard register scanning functions.
3491 ----------------------------------------------------------------------------*/
3492
3493
3494 /* Mark a register in SET. Hard registers in large modes get all
3495 of their component registers set as well. */
3496
3497 static void
3498 df_mark_reg (rtx reg, void *vset)
3499 {
3500 bitmap_set_range ((bitmap) vset, REGNO (reg), REG_NREGS (reg));
3501 }
3502
3503
3504 /* Set the bit for regs that are considered being defined at the entry. */
3505
3506 static void
3507 df_get_entry_block_def_set (bitmap entry_block_defs)
3508 {
3509 rtx r;
3510 int i;
3511
3512 bitmap_clear (entry_block_defs);
3513
3514 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3515 {
3516 if (global_regs[i])
3517 bitmap_set_bit (entry_block_defs, i);
3518 if (FUNCTION_ARG_REGNO_P (i))
3519 bitmap_set_bit (entry_block_defs, INCOMING_REGNO (i));
3520 }
3521
3522 /* The always important stack pointer. */
3523 bitmap_set_bit (entry_block_defs, STACK_POINTER_REGNUM);
3524
3525 /* Once the prologue has been generated, all of these registers
3526 should just show up in the first regular block. */
3527 if (HAVE_prologue && epilogue_completed)
3528 {
3529 /* Defs for the callee saved registers are inserted so that the
3530 pushes have some defining location. */
3531 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3532 if ((call_used_regs[i] == 0) && (df_regs_ever_live_p (i)))
3533 bitmap_set_bit (entry_block_defs, i);
3534 }
3535
3536 r = targetm.calls.struct_value_rtx (current_function_decl, true);
3537 if (r && REG_P (r))
3538 bitmap_set_bit (entry_block_defs, REGNO (r));
3539
3540 /* If the function has an incoming STATIC_CHAIN, it has to show up
3541 in the entry def set. */
3542 r = targetm.calls.static_chain (current_function_decl, true);
3543 if (r && REG_P (r))
3544 bitmap_set_bit (entry_block_defs, REGNO (r));
3545
3546 if ((!reload_completed) || frame_pointer_needed)
3547 {
3548 /* Any reference to any pseudo before reload is a potential
3549 reference of the frame pointer. */
3550 bitmap_set_bit (entry_block_defs, FRAME_POINTER_REGNUM);
3551
3552 /* If they are different, also mark the hard frame pointer as live. */
3553 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
3554 && !LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
3555 bitmap_set_bit (entry_block_defs, HARD_FRAME_POINTER_REGNUM);
3556 }
3557
3558 /* These registers are live everywhere. */
3559 if (!reload_completed)
3560 {
3561 /* Pseudos with argument area equivalences may require
3562 reloading via the argument pointer. */
3563 if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3564 && fixed_regs[ARG_POINTER_REGNUM])
3565 bitmap_set_bit (entry_block_defs, ARG_POINTER_REGNUM);
3566
3567 /* Any constant, or pseudo with constant equivalences, may
3568 require reloading from memory using the pic register. */
3569 unsigned int picreg = PIC_OFFSET_TABLE_REGNUM;
3570 if (picreg != INVALID_REGNUM
3571 && fixed_regs[picreg])
3572 bitmap_set_bit (entry_block_defs, picreg);
3573 }
3574
3575 #ifdef INCOMING_RETURN_ADDR_RTX
3576 if (REG_P (INCOMING_RETURN_ADDR_RTX))
3577 bitmap_set_bit (entry_block_defs, REGNO (INCOMING_RETURN_ADDR_RTX));
3578 #endif
3579
3580 targetm.extra_live_on_entry (entry_block_defs);
3581 }
3582
3583
3584 /* Return the (conservative) set of hard registers that are defined on
3585 entry to the function.
3586 It uses df->entry_block_defs to determine which register
3587 reference to include. */
3588
3589 static void
3590 df_entry_block_defs_collect (struct df_collection_rec *collection_rec,
3591 bitmap entry_block_defs)
3592 {
3593 unsigned int i;
3594 bitmap_iterator bi;
3595
3596 EXECUTE_IF_SET_IN_BITMAP (entry_block_defs, 0, i, bi)
3597 {
3598 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
3599 ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, DF_REF_REG_DEF, 0);
3600 }
3601
3602 df_canonize_collection_rec (collection_rec);
3603 }
3604
3605
3606 /* Record the (conservative) set of hard registers that are defined on
3607 entry to the function. */
3608
3609 static void
3610 df_record_entry_block_defs (bitmap entry_block_defs)
3611 {
3612 struct df_collection_rec collection_rec;
3613 df_entry_block_defs_collect (&collection_rec, entry_block_defs);
3614
3615 /* Process bb_refs chain */
3616 df_refs_add_to_chains (&collection_rec,
3617 BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK),
3618 NULL,
3619 copy_defs);
3620 }
3621
3622
3623 /* Update the defs in the entry block. */
3624
3625 void
3626 df_update_entry_block_defs (void)
3627 {
3628 bitmap_head refs;
3629 bool changed = false;
3630
3631 bitmap_initialize (&refs, &df_bitmap_obstack);
3632 df_get_entry_block_def_set (&refs);
3633 if (df->entry_block_defs)
3634 {
3635 if (!bitmap_equal_p (df->entry_block_defs, &refs))
3636 {
3637 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (ENTRY_BLOCK);
3638 df_ref_chain_delete_du_chain (bb_info->artificial_defs);
3639 df_ref_chain_delete (bb_info->artificial_defs);
3640 bb_info->artificial_defs = NULL;
3641 changed = true;
3642 }
3643 }
3644 else
3645 {
3646 struct df_scan_problem_data *problem_data
3647 = (struct df_scan_problem_data *) df_scan->problem_data;
3648 gcc_unreachable ();
3649 df->entry_block_defs = BITMAP_ALLOC (&problem_data->reg_bitmaps);
3650 changed = true;
3651 }
3652
3653 if (changed)
3654 {
3655 df_record_entry_block_defs (&refs);
3656 bitmap_copy (df->entry_block_defs, &refs);
3657 df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK));
3658 }
3659 bitmap_clear (&refs);
3660 }
3661
3662
3663 /* Set the bit for regs that are considered being used at the exit. */
3664
3665 static void
3666 df_get_exit_block_use_set (bitmap exit_block_uses)
3667 {
3668 unsigned int i;
3669 unsigned int picreg = PIC_OFFSET_TABLE_REGNUM;
3670
3671 bitmap_clear (exit_block_uses);
3672
3673 /* Stack pointer is always live at the exit. */
3674 bitmap_set_bit (exit_block_uses, STACK_POINTER_REGNUM);
3675
3676 /* Mark the frame pointer if needed at the end of the function.
3677 If we end up eliminating it, it will be removed from the live
3678 list of each basic block by reload. */
3679
3680 if ((!reload_completed) || frame_pointer_needed)
3681 {
3682 bitmap_set_bit (exit_block_uses, FRAME_POINTER_REGNUM);
3683
3684 /* If they are different, also mark the hard frame pointer as live. */
3685 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
3686 && !LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
3687 bitmap_set_bit (exit_block_uses, HARD_FRAME_POINTER_REGNUM);
3688 }
3689
3690 /* Many architectures have a GP register even without flag_pic.
3691 Assume the pic register is not in use, or will be handled by
3692 other means, if it is not fixed. */
3693 if (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
3694 && picreg != INVALID_REGNUM
3695 && fixed_regs[picreg])
3696 bitmap_set_bit (exit_block_uses, picreg);
3697
3698 /* Mark all global registers, and all registers used by the
3699 epilogue as being live at the end of the function since they
3700 may be referenced by our caller. */
3701 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3702 if (global_regs[i] || EPILOGUE_USES (i))
3703 bitmap_set_bit (exit_block_uses, i);
3704
3705 if (HAVE_epilogue && epilogue_completed)
3706 {
3707 /* Mark all call-saved registers that we actually used. */
3708 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3709 if (df_regs_ever_live_p (i) && !LOCAL_REGNO (i)
3710 && !TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
3711 bitmap_set_bit (exit_block_uses, i);
3712 }
3713
3714 /* Mark the registers that will contain data for the handler. */
3715 if (reload_completed && crtl->calls_eh_return)
3716 for (i = 0; ; ++i)
3717 {
3718 unsigned regno = EH_RETURN_DATA_REGNO (i);
3719 if (regno == INVALID_REGNUM)
3720 break;
3721 bitmap_set_bit (exit_block_uses, regno);
3722 }
3723
3724 #ifdef EH_RETURN_STACKADJ_RTX
3725 if ((!HAVE_epilogue || ! epilogue_completed)
3726 && crtl->calls_eh_return)
3727 {
3728 rtx tmp = EH_RETURN_STACKADJ_RTX;
3729 if (tmp && REG_P (tmp))
3730 df_mark_reg (tmp, exit_block_uses);
3731 }
3732 #endif
3733
3734 #ifdef EH_RETURN_HANDLER_RTX
3735 if ((!HAVE_epilogue || ! epilogue_completed)
3736 && crtl->calls_eh_return)
3737 {
3738 rtx tmp = EH_RETURN_HANDLER_RTX;
3739 if (tmp && REG_P (tmp))
3740 df_mark_reg (tmp, exit_block_uses);
3741 }
3742 #endif
3743
3744 /* Mark function return value. */
3745 diddle_return_value (df_mark_reg, (void*) exit_block_uses);
3746 }
3747
3748
3749 /* Return the refs of hard registers that are used in the exit block.
3750 It uses df->exit_block_uses to determine register to include. */
3751
3752 static void
3753 df_exit_block_uses_collect (struct df_collection_rec *collection_rec, bitmap exit_block_uses)
3754 {
3755 unsigned int i;
3756 bitmap_iterator bi;
3757
3758 EXECUTE_IF_SET_IN_BITMAP (exit_block_uses, 0, i, bi)
3759 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
3760 EXIT_BLOCK_PTR_FOR_FN (cfun), NULL, DF_REF_REG_USE, 0);
3761
3762 /* It is deliberate that this is not put in the exit block uses but
3763 I do not know why. */
3764 if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3765 && reload_completed
3766 && !bitmap_bit_p (exit_block_uses, ARG_POINTER_REGNUM)
3767 && bb_has_eh_pred (EXIT_BLOCK_PTR_FOR_FN (cfun))
3768 && fixed_regs[ARG_POINTER_REGNUM])
3769 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL,
3770 EXIT_BLOCK_PTR_FOR_FN (cfun), NULL, DF_REF_REG_USE, 0);
3771
3772 df_canonize_collection_rec (collection_rec);
3773 }
3774
3775
3776 /* Record the set of hard registers that are used in the exit block.
3777 It uses df->exit_block_uses to determine which bit to include. */
3778
3779 static void
3780 df_record_exit_block_uses (bitmap exit_block_uses)
3781 {
3782 struct df_collection_rec collection_rec;
3783 df_exit_block_uses_collect (&collection_rec, exit_block_uses);
3784
3785 /* Process bb_refs chain */
3786 df_refs_add_to_chains (&collection_rec,
3787 BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK),
3788 NULL,
3789 copy_uses);
3790 }
3791
3792
3793 /* Update the uses in the exit block. */
3794
3795 void
3796 df_update_exit_block_uses (void)
3797 {
3798 bitmap_head refs;
3799 bool changed = false;
3800
3801 bitmap_initialize (&refs, &df_bitmap_obstack);
3802 df_get_exit_block_use_set (&refs);
3803 if (df->exit_block_uses)
3804 {
3805 if (!bitmap_equal_p (df->exit_block_uses, &refs))
3806 {
3807 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (EXIT_BLOCK);
3808 df_ref_chain_delete_du_chain (bb_info->artificial_uses);
3809 df_ref_chain_delete (bb_info->artificial_uses);
3810 bb_info->artificial_uses = NULL;
3811 changed = true;
3812 }
3813 }
3814 else
3815 {
3816 struct df_scan_problem_data *problem_data
3817 = (struct df_scan_problem_data *) df_scan->problem_data;
3818 gcc_unreachable ();
3819 df->exit_block_uses = BITMAP_ALLOC (&problem_data->reg_bitmaps);
3820 changed = true;
3821 }
3822
3823 if (changed)
3824 {
3825 df_record_exit_block_uses (&refs);
3826 bitmap_copy (df->exit_block_uses,& refs);
3827 df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK));
3828 }
3829 bitmap_clear (&refs);
3830 }
3831
3832 static bool initialized = false;
3833
3834
3835 /* Initialize some platform specific structures. */
3836
3837 void
3838 df_hard_reg_init (void)
3839 {
3840 #ifdef ELIMINABLE_REGS
3841 int i;
3842 static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;
3843 #endif
3844 if (initialized)
3845 return;
3846
3847 /* Record which registers will be eliminated. We use this in
3848 mark_used_regs. */
3849 CLEAR_HARD_REG_SET (elim_reg_set);
3850
3851 #ifdef ELIMINABLE_REGS
3852 for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++)
3853 SET_HARD_REG_BIT (elim_reg_set, eliminables[i].from);
3854 #else
3855 SET_HARD_REG_BIT (elim_reg_set, FRAME_POINTER_REGNUM);
3856 #endif
3857
3858 initialized = true;
3859 }
3860
3861
3862 /* Recompute the parts of scanning that are based on regs_ever_live
3863 because something changed in that array. */
3864
3865 void
3866 df_update_entry_exit_and_calls (void)
3867 {
3868 basic_block bb;
3869
3870 df_update_entry_block_defs ();
3871 df_update_exit_block_uses ();
3872
3873 /* The call insns need to be rescanned because there may be changes
3874 in the set of registers clobbered across the call. */
3875 FOR_EACH_BB_FN (bb, cfun)
3876 {
3877 rtx_insn *insn;
3878 FOR_BB_INSNS (bb, insn)
3879 {
3880 if (INSN_P (insn) && CALL_P (insn))
3881 df_insn_rescan (insn);
3882 }
3883 }
3884 }
3885
3886
3887 /* Return true if hard REG is actually used in the some instruction.
3888 There are a fair number of conditions that affect the setting of
3889 this array. See the comment in df.h for df->hard_regs_live_count
3890 for the conditions that this array is set. */
3891
3892 bool
3893 df_hard_reg_used_p (unsigned int reg)
3894 {
3895 return df->hard_regs_live_count[reg] != 0;
3896 }
3897
3898
3899 /* A count of the number of times REG is actually used in the some
3900 instruction. There are a fair number of conditions that affect the
3901 setting of this array. See the comment in df.h for
3902 df->hard_regs_live_count for the conditions that this array is
3903 set. */
3904
3905
3906 unsigned int
3907 df_hard_reg_used_count (unsigned int reg)
3908 {
3909 return df->hard_regs_live_count[reg];
3910 }
3911
3912
3913 /* Get the value of regs_ever_live[REGNO]. */
3914
3915 bool
3916 df_regs_ever_live_p (unsigned int regno)
3917 {
3918 return regs_ever_live[regno];
3919 }
3920
3921
3922 /* Set regs_ever_live[REGNO] to VALUE. If this cause regs_ever_live
3923 to change, schedule that change for the next update. */
3924
3925 void
3926 df_set_regs_ever_live (unsigned int regno, bool value)
3927 {
3928 if (regs_ever_live[regno] == value)
3929 return;
3930
3931 regs_ever_live[regno] = value;
3932 if (df)
3933 df->redo_entry_and_exit = true;
3934 }
3935
3936
3937 /* Compute "regs_ever_live" information from the underlying df
3938 information. Set the vector to all false if RESET. */
3939
3940 void
3941 df_compute_regs_ever_live (bool reset)
3942 {
3943 unsigned int i;
3944 bool changed = df->redo_entry_and_exit;
3945
3946 if (reset)
3947 memset (regs_ever_live, 0, sizeof (regs_ever_live));
3948
3949 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3950 if ((!regs_ever_live[i]) && df_hard_reg_used_p (i))
3951 {
3952 regs_ever_live[i] = true;
3953 changed = true;
3954 }
3955 if (changed)
3956 df_update_entry_exit_and_calls ();
3957 df->redo_entry_and_exit = false;
3958 }
3959
3960 \f
3961 /*----------------------------------------------------------------------------
3962 Dataflow ref information verification functions.
3963
3964 df_reg_chain_mark (refs, regno, is_def, is_eq_use)
3965 df_reg_chain_verify_unmarked (refs)
3966 df_refs_verify (vec<stack, va_df_ref>, ref*, bool)
3967 df_mws_verify (mw*, mw*, bool)
3968 df_insn_refs_verify (collection_rec, bb, insn, bool)
3969 df_bb_refs_verify (bb, refs, bool)
3970 df_bb_verify (bb)
3971 df_exit_block_bitmap_verify (bool)
3972 df_entry_block_bitmap_verify (bool)
3973 df_scan_verify ()
3974 ----------------------------------------------------------------------------*/
3975
3976
3977 /* Mark all refs in the reg chain. Verify that all of the registers
3978 are in the correct chain. */
3979
3980 static unsigned int
3981 df_reg_chain_mark (df_ref refs, unsigned int regno,
3982 bool is_def, bool is_eq_use)
3983 {
3984 unsigned int count = 0;
3985 df_ref ref;
3986 for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
3987 {
3988 gcc_assert (!DF_REF_IS_REG_MARKED (ref));
3989
3990 /* If there are no def-use or use-def chains, make sure that all
3991 of the chains are clear. */
3992 if (!df_chain)
3993 gcc_assert (!DF_REF_CHAIN (ref));
3994
3995 /* Check to make sure the ref is in the correct chain. */
3996 gcc_assert (DF_REF_REGNO (ref) == regno);
3997 if (is_def)
3998 gcc_assert (DF_REF_REG_DEF_P (ref));
3999 else
4000 gcc_assert (!DF_REF_REG_DEF_P (ref));
4001
4002 if (is_eq_use)
4003 gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE));
4004 else
4005 gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE) == 0);
4006
4007 if (DF_REF_NEXT_REG (ref))
4008 gcc_assert (DF_REF_PREV_REG (DF_REF_NEXT_REG (ref)) == ref);
4009 count++;
4010 DF_REF_REG_MARK (ref);
4011 }
4012 return count;
4013 }
4014
4015
4016 /* Verify that all of the registers in the chain are unmarked. */
4017
4018 static void
4019 df_reg_chain_verify_unmarked (df_ref refs)
4020 {
4021 df_ref ref;
4022 for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
4023 gcc_assert (!DF_REF_IS_REG_MARKED (ref));
4024 }
4025
4026
4027 /* Verify that NEW_REC and OLD_REC have exactly the same members. */
4028
4029 static bool
4030 df_refs_verify (const vec<df_ref, va_heap> *new_rec, df_ref old_rec,
4031 bool abort_if_fail)
4032 {
4033 unsigned int ix;
4034 df_ref new_ref;
4035
4036 FOR_EACH_VEC_ELT (*new_rec, ix, new_ref)
4037 {
4038 if (old_rec == NULL || !df_ref_equal_p (new_ref, old_rec))
4039 {
4040 if (abort_if_fail)
4041 gcc_assert (0);
4042 else
4043 return false;
4044 }
4045
4046 /* Abort if fail is called from the function level verifier. If
4047 that is the context, mark this reg as being seem. */
4048 if (abort_if_fail)
4049 {
4050 gcc_assert (DF_REF_IS_REG_MARKED (old_rec));
4051 DF_REF_REG_UNMARK (old_rec);
4052 }
4053
4054 old_rec = DF_REF_NEXT_LOC (old_rec);
4055 }
4056
4057 if (abort_if_fail)
4058 gcc_assert (old_rec == NULL);
4059 else
4060 return old_rec == NULL;
4061 return false;
4062 }
4063
4064
4065 /* Verify that NEW_REC and OLD_REC have exactly the same members. */
4066
4067 static bool
4068 df_mws_verify (const vec<df_mw_hardreg_ptr, va_heap> *new_rec,
4069 struct df_mw_hardreg *old_rec,
4070 bool abort_if_fail)
4071 {
4072 unsigned int ix;
4073 struct df_mw_hardreg *new_reg;
4074
4075 FOR_EACH_VEC_ELT (*new_rec, ix, new_reg)
4076 {
4077 if (old_rec == NULL || !df_mw_equal_p (new_reg, old_rec))
4078 {
4079 if (abort_if_fail)
4080 gcc_assert (0);
4081 else
4082 return false;
4083 }
4084 old_rec = DF_MWS_NEXT (old_rec);
4085 }
4086
4087 if (abort_if_fail)
4088 gcc_assert (old_rec == NULL);
4089 else
4090 return old_rec == NULL;
4091 return false;
4092 }
4093
4094
4095 /* Return true if the existing insn refs information is complete and
4096 correct. Otherwise (i.e. if there's any missing or extra refs),
4097 return the correct df_ref chain in REFS_RETURN.
4098
4099 If ABORT_IF_FAIL, leave the refs that are verified (already in the
4100 ref chain) as DF_REF_MARKED(). If it's false, then it's a per-insn
4101 verification mode instead of the whole function, so unmark
4102 everything.
4103
4104 If ABORT_IF_FAIL is set, this function never returns false. */
4105
4106 static bool
4107 df_insn_refs_verify (struct df_collection_rec *collection_rec,
4108 basic_block bb,
4109 rtx_insn *insn,
4110 bool abort_if_fail)
4111 {
4112 bool ret1, ret2, ret3, ret4;
4113 unsigned int uid = INSN_UID (insn);
4114 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
4115
4116 df_insn_refs_collect (collection_rec, bb, insn_info);
4117
4118 /* Unfortunately we cannot opt out early if one of these is not
4119 right because the marks will not get cleared. */
4120 ret1 = df_refs_verify (&collection_rec->def_vec, DF_INSN_UID_DEFS (uid),
4121 abort_if_fail);
4122 ret2 = df_refs_verify (&collection_rec->use_vec, DF_INSN_UID_USES (uid),
4123 abort_if_fail);
4124 ret3 = df_refs_verify (&collection_rec->eq_use_vec, DF_INSN_UID_EQ_USES (uid),
4125 abort_if_fail);
4126 ret4 = df_mws_verify (&collection_rec->mw_vec, DF_INSN_UID_MWS (uid),
4127 abort_if_fail);
4128 return (ret1 && ret2 && ret3 && ret4);
4129 }
4130
4131
4132 /* Return true if all refs in the basic block are correct and complete.
4133 Due to df_ref_chain_verify, it will cause all refs
4134 that are verified to have DF_REF_MARK bit set. */
4135
4136 static bool
4137 df_bb_verify (basic_block bb)
4138 {
4139 rtx_insn *insn;
4140 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb->index);
4141 struct df_collection_rec collection_rec;
4142
4143 gcc_assert (bb_info);
4144
4145 /* Scan the block, one insn at a time, from beginning to end. */
4146 FOR_BB_INSNS_REVERSE (bb, insn)
4147 {
4148 if (!INSN_P (insn))
4149 continue;
4150 df_insn_refs_verify (&collection_rec, bb, insn, true);
4151 df_free_collection_rec (&collection_rec);
4152 }
4153
4154 /* Do the artificial defs and uses. */
4155 df_bb_refs_collect (&collection_rec, bb);
4156 df_refs_verify (&collection_rec.def_vec, df_get_artificial_defs (bb->index), true);
4157 df_refs_verify (&collection_rec.use_vec, df_get_artificial_uses (bb->index), true);
4158 df_free_collection_rec (&collection_rec);
4159
4160 return true;
4161 }
4162
4163
4164 /* Returns true if the entry block has correct and complete df_ref set.
4165 If not it either aborts if ABORT_IF_FAIL is true or returns false. */
4166
4167 static bool
4168 df_entry_block_bitmap_verify (bool abort_if_fail)
4169 {
4170 bitmap_head entry_block_defs;
4171 bool is_eq;
4172
4173 bitmap_initialize (&entry_block_defs, &df_bitmap_obstack);
4174 df_get_entry_block_def_set (&entry_block_defs);
4175
4176 is_eq = bitmap_equal_p (&entry_block_defs, df->entry_block_defs);
4177
4178 if (!is_eq && abort_if_fail)
4179 {
4180 fprintf (stderr, "entry_block_defs = ");
4181 df_print_regset (stderr, &entry_block_defs);
4182 fprintf (stderr, "df->entry_block_defs = ");
4183 df_print_regset (stderr, df->entry_block_defs);
4184 gcc_assert (0);
4185 }
4186
4187 bitmap_clear (&entry_block_defs);
4188
4189 return is_eq;
4190 }
4191
4192
4193 /* Returns true if the exit block has correct and complete df_ref set.
4194 If not it either aborts if ABORT_IF_FAIL is true or returns false. */
4195
4196 static bool
4197 df_exit_block_bitmap_verify (bool abort_if_fail)
4198 {
4199 bitmap_head exit_block_uses;
4200 bool is_eq;
4201
4202 bitmap_initialize (&exit_block_uses, &df_bitmap_obstack);
4203 df_get_exit_block_use_set (&exit_block_uses);
4204
4205 is_eq = bitmap_equal_p (&exit_block_uses, df->exit_block_uses);
4206
4207 if (!is_eq && abort_if_fail)
4208 {
4209 fprintf (stderr, "exit_block_uses = ");
4210 df_print_regset (stderr, &exit_block_uses);
4211 fprintf (stderr, "df->exit_block_uses = ");
4212 df_print_regset (stderr, df->exit_block_uses);
4213 gcc_assert (0);
4214 }
4215
4216 bitmap_clear (&exit_block_uses);
4217
4218 return is_eq;
4219 }
4220
4221
4222 /* Return true if df_ref information for all insns in all blocks are
4223 correct and complete. */
4224
4225 void
4226 df_scan_verify (void)
4227 {
4228 unsigned int i;
4229 basic_block bb;
4230 bitmap_head regular_block_artificial_uses;
4231 bitmap_head eh_block_artificial_uses;
4232
4233 if (!df)
4234 return;
4235
4236 /* Verification is a 4 step process. */
4237
4238 /* (1) All of the refs are marked by going through the reg chains. */
4239 for (i = 0; i < DF_REG_SIZE (df); i++)
4240 {
4241 gcc_assert (df_reg_chain_mark (DF_REG_DEF_CHAIN (i), i, true, false)
4242 == DF_REG_DEF_COUNT (i));
4243 gcc_assert (df_reg_chain_mark (DF_REG_USE_CHAIN (i), i, false, false)
4244 == DF_REG_USE_COUNT (i));
4245 gcc_assert (df_reg_chain_mark (DF_REG_EQ_USE_CHAIN (i), i, false, true)
4246 == DF_REG_EQ_USE_COUNT (i));
4247 }
4248
4249 /* (2) There are various bitmaps whose value may change over the
4250 course of the compilation. This step recomputes them to make
4251 sure that they have not slipped out of date. */
4252 bitmap_initialize (&regular_block_artificial_uses, &df_bitmap_obstack);
4253 bitmap_initialize (&eh_block_artificial_uses, &df_bitmap_obstack);
4254
4255 df_get_regular_block_artificial_uses (&regular_block_artificial_uses);
4256 df_get_eh_block_artificial_uses (&eh_block_artificial_uses);
4257
4258 bitmap_ior_into (&eh_block_artificial_uses,
4259 &regular_block_artificial_uses);
4260
4261 /* Check artificial_uses bitmaps didn't change. */
4262 gcc_assert (bitmap_equal_p (&regular_block_artificial_uses,
4263 &df->regular_block_artificial_uses));
4264 gcc_assert (bitmap_equal_p (&eh_block_artificial_uses,
4265 &df->eh_block_artificial_uses));
4266
4267 bitmap_clear (&regular_block_artificial_uses);
4268 bitmap_clear (&eh_block_artificial_uses);
4269
4270 /* Verify entry block and exit block. These only verify the bitmaps,
4271 the refs are verified in df_bb_verify. */
4272 df_entry_block_bitmap_verify (true);
4273 df_exit_block_bitmap_verify (true);
4274
4275 /* (3) All of the insns in all of the blocks are traversed and the
4276 marks are cleared both in the artificial refs attached to the
4277 blocks and the real refs inside the insns. It is a failure to
4278 clear a mark that has not been set as this means that the ref in
4279 the block or insn was not in the reg chain. */
4280
4281 FOR_ALL_BB_FN (bb, cfun)
4282 df_bb_verify (bb);
4283
4284 /* (4) See if all reg chains are traversed a second time. This time
4285 a check is made that the marks are clear. A set mark would be a
4286 from a reg that is not in any insn or basic block. */
4287
4288 for (i = 0; i < DF_REG_SIZE (df); i++)
4289 {
4290 df_reg_chain_verify_unmarked (DF_REG_DEF_CHAIN (i));
4291 df_reg_chain_verify_unmarked (DF_REG_USE_CHAIN (i));
4292 df_reg_chain_verify_unmarked (DF_REG_EQ_USE_CHAIN (i));
4293 }
4294 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org