PR target/58115
[official-gcc.git] / gcc / df-core.c
bloba3085c174ec667a5236a59a124d699dedb6a220e
1 /* Allocation for dataflow support routines.
2 Copyright (C) 1999-2014 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).
8 This file is part of GCC.
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.
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.
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/>. */
25 OVERVIEW:
27 The files in this collection (df*.c,df.h) provide a general framework
28 for solving dataflow problems. The global dataflow is performed using
29 a good implementation of iterative dataflow analysis.
31 The file df-problems.c provides problem instance for the most common
32 dataflow problems: reaching defs, upward exposed uses, live variables,
33 uninitialized variables, def-use chains, and use-def chains. However,
34 the interface allows other dataflow problems to be defined as well.
36 Dataflow analysis is available in most of the rtl backend (the parts
37 between pass_df_initialize and pass_df_finish). It is quite likely
38 that these boundaries will be expanded in the future. The only
39 requirement is that there be a correct control flow graph.
41 There are three variations of the live variable problem that are
42 available whenever dataflow is available. The LR problem finds the
43 areas that can reach a use of a variable, the UR problems finds the
44 areas that can be reached from a definition of a variable. The LIVE
45 problem finds the intersection of these two areas.
47 There are several optional problems. These can be enabled when they
48 are needed and disabled when they are not needed.
50 Dataflow problems are generally solved in three layers. The bottom
51 layer is called scanning where a data structure is built for each rtl
52 insn that describes the set of defs and uses of that insn. Scanning
53 is generally kept up to date, i.e. as the insns changes, the scanned
54 version of that insn changes also. There are various mechanisms for
55 making this happen and are described in the INCREMENTAL SCANNING
56 section.
58 In the middle layer, basic blocks are scanned to produce transfer
59 functions which describe the effects of that block on the global
60 dataflow solution. The transfer functions are only rebuilt if the
61 some instruction within the block has changed.
63 The top layer is the dataflow solution itself. The dataflow solution
64 is computed by using an efficient iterative solver and the transfer
65 functions. The dataflow solution must be recomputed whenever the
66 control changes or if one of the transfer function changes.
69 USAGE:
71 Here is an example of using the dataflow routines.
73 df_[chain,live,note,rd]_add_problem (flags);
75 df_set_blocks (blocks);
77 df_analyze ();
79 df_dump (stderr);
81 df_finish_pass (false);
83 DF_[chain,live,note,rd]_ADD_PROBLEM adds a problem, defined by an
84 instance to struct df_problem, to the set of problems solved in this
85 instance of df. All calls to add a problem for a given instance of df
86 must occur before the first call to DF_ANALYZE.
88 Problems can be dependent on other problems. For instance, solving
89 def-use or use-def chains is dependent on solving reaching
90 definitions. As long as these dependencies are listed in the problem
91 definition, the order of adding the problems is not material.
92 Otherwise, the problems will be solved in the order of calls to
93 df_add_problem. Note that it is not necessary to have a problem. In
94 that case, df will just be used to do the scanning.
98 DF_SET_BLOCKS is an optional call used to define a region of the
99 function on which the analysis will be performed. The normal case is
100 to analyze the entire function and no call to df_set_blocks is made.
101 DF_SET_BLOCKS only effects the blocks that are effected when computing
102 the transfer functions and final solution. The insn level information
103 is always kept up to date.
105 When a subset is given, the analysis behaves as if the function only
106 contains those blocks and any edges that occur directly between the
107 blocks in the set. Care should be taken to call df_set_blocks right
108 before the call to analyze in order to eliminate the possibility that
109 optimizations that reorder blocks invalidate the bitvector.
111 DF_ANALYZE causes all of the defined problems to be (re)solved. When
112 DF_ANALYZE is completes, the IN and OUT sets for each basic block
113 contain the computer information. The DF_*_BB_INFO macros can be used
114 to access these bitvectors. All deferred rescannings are down before
115 the transfer functions are recomputed.
117 DF_DUMP can then be called to dump the information produce to some
118 file. This calls DF_DUMP_START, to print the information that is not
119 basic block specific, and then calls DF_DUMP_TOP and DF_DUMP_BOTTOM
120 for each block to print the basic specific information. These parts
121 can all be called separately as part of a larger dump function.
124 DF_FINISH_PASS causes df_remove_problem to be called on all of the
125 optional problems. It also causes any insns whose scanning has been
126 deferred to be rescanned as well as clears all of the changeable flags.
127 Setting the pass manager TODO_df_finish flag causes this function to
128 be run. However, the pass manager will call df_finish_pass AFTER the
129 pass dumping has been done, so if you want to see the results of the
130 optional problems in the pass dumps, use the TODO flag rather than
131 calling the function yourself.
133 INCREMENTAL SCANNING
135 There are four ways of doing the incremental scanning:
137 1) Immediate rescanning - Calls to df_insn_rescan, df_notes_rescan,
138 df_bb_delete, df_insn_change_bb have been added to most of
139 the low level service functions that maintain the cfg and change
140 rtl. Calling and of these routines many cause some number of insns
141 to be rescanned.
143 For most modern rtl passes, this is certainly the easiest way to
144 manage rescanning the insns. This technique also has the advantage
145 that the scanning information is always correct and can be relied
146 upon even after changes have been made to the instructions. This
147 technique is contra indicated in several cases:
149 a) If def-use chains OR use-def chains (but not both) are built,
150 using this is SIMPLY WRONG. The problem is that when a ref is
151 deleted that is the target of an edge, there is not enough
152 information to efficiently find the source of the edge and
153 delete the edge. This leaves a dangling reference that may
154 cause problems.
156 b) If def-use chains AND use-def chains are built, this may
157 produce unexpected results. The problem is that the incremental
158 scanning of an insn does not know how to repair the chains that
159 point into an insn when the insn changes. So the incremental
160 scanning just deletes the chains that enter and exit the insn
161 being changed. The dangling reference issue in (a) is not a
162 problem here, but if the pass is depending on the chains being
163 maintained after insns have been modified, this technique will
164 not do the correct thing.
166 c) If the pass modifies insns several times, this incremental
167 updating may be expensive.
169 d) If the pass modifies all of the insns, as does register
170 allocation, it is simply better to rescan the entire function.
172 2) Deferred rescanning - Calls to df_insn_rescan, df_notes_rescan, and
173 df_insn_delete do not immediately change the insn but instead make
174 a note that the insn needs to be rescanned. The next call to
175 df_analyze, df_finish_pass, or df_process_deferred_rescans will
176 cause all of the pending rescans to be processed.
178 This is the technique of choice if either 1a, 1b, or 1c are issues
179 in the pass. In the case of 1a or 1b, a call to df_finish_pass
180 (either manually or via TODO_df_finish) should be made before the
181 next call to df_analyze or df_process_deferred_rescans.
183 This mode is also used by a few passes that still rely on note_uses,
184 note_stores and for_each_rtx instead of using the DF data. This
185 can be said to fall under case 1c.
187 To enable this mode, call df_set_flags (DF_DEFER_INSN_RESCAN).
188 (This mode can be cleared by calling df_clear_flags
189 (DF_DEFER_INSN_RESCAN) but this does not cause the deferred insns to
190 be rescanned.
192 3) Total rescanning - In this mode the rescanning is disabled.
193 Only when insns are deleted is the df information associated with
194 it also deleted. At the end of the pass, a call must be made to
195 df_insn_rescan_all. This method is used by the register allocator
196 since it generally changes each insn multiple times (once for each ref)
197 and does not need to make use of the updated scanning information.
199 4) Do it yourself - In this mechanism, the pass updates the insns
200 itself using the low level df primitives. Currently no pass does
201 this, but it has the advantage that it is quite efficient given
202 that the pass generally has exact knowledge of what it is changing.
204 DATA STRUCTURES
206 Scanning produces a `struct df_ref' data structure (ref) is allocated
207 for every register reference (def or use) and this records the insn
208 and bb the ref is found within. The refs are linked together in
209 chains of uses and defs for each insn and for each register. Each ref
210 also has a chain field that links all the use refs for a def or all
211 the def refs for a use. This is used to create use-def or def-use
212 chains.
214 Different optimizations have different needs. Ultimately, only
215 register allocation and schedulers should be using the bitmaps
216 produced for the live register and uninitialized register problems.
217 The rest of the backend should be upgraded to using and maintaining
218 the linked information such as def use or use def chains.
221 PHILOSOPHY:
223 While incremental bitmaps are not worthwhile to maintain, incremental
224 chains may be perfectly reasonable. The fastest way to build chains
225 from scratch or after significant modifications is to build reaching
226 definitions (RD) and build the chains from this.
228 However, general algorithms for maintaining use-def or def-use chains
229 are not practical. The amount of work to recompute the chain any
230 chain after an arbitrary change is large. However, with a modest
231 amount of work it is generally possible to have the application that
232 uses the chains keep them up to date. The high level knowledge of
233 what is really happening is essential to crafting efficient
234 incremental algorithms.
236 As for the bit vector problems, there is no interface to give a set of
237 blocks over with to resolve the iteration. In general, restarting a
238 dataflow iteration is difficult and expensive. Again, the best way to
239 keep the dataflow information up to data (if this is really what is
240 needed) it to formulate a problem specific solution.
242 There are fine grained calls for creating and deleting references from
243 instructions in df-scan.c. However, these are not currently connected
244 to the engine that resolves the dataflow equations.
247 DATA STRUCTURES:
249 The basic object is a DF_REF (reference) and this may either be a
250 DEF (definition) or a USE of a register.
252 These are linked into a variety of lists; namely reg-def, reg-use,
253 insn-def, insn-use, def-use, and use-def lists. For example, the
254 reg-def lists contain all the locations that define a given register
255 while the insn-use lists contain all the locations that use a
256 register.
258 Note that the reg-def and reg-use chains are generally short for
259 pseudos and long for the hard registers.
261 ACCESSING INSNS:
263 1) The df insn information is kept in an array of DF_INSN_INFO objects.
264 The array is indexed by insn uid, and every DF_REF points to the
265 DF_INSN_INFO object of the insn that contains the reference.
267 2) Each insn has three sets of refs, which are linked into one of three
268 lists: The insn's defs list (accessed by the DF_INSN_INFO_DEFS,
269 DF_INSN_DEFS, or DF_INSN_UID_DEFS macros), the insn's uses list
270 (accessed by the DF_INSN_INFO_USES, DF_INSN_USES, or
271 DF_INSN_UID_USES macros) or the insn's eq_uses list (accessed by the
272 DF_INSN_INFO_EQ_USES, DF_INSN_EQ_USES or DF_INSN_UID_EQ_USES macros).
273 The latter list are the list of references in REG_EQUAL or REG_EQUIV
274 notes. These macros produce a ref (or NULL), the rest of the list
275 can be obtained by traversal of the NEXT_REF field (accessed by the
276 DF_REF_NEXT_REF macro.) There is no significance to the ordering of
277 the uses or refs in an instruction.
279 3) Each insn has a logical uid field (LUID) which is stored in the
280 DF_INSN_INFO object for the insn. The LUID field is accessed by
281 the DF_INSN_INFO_LUID, DF_INSN_LUID, and DF_INSN_UID_LUID macros.
282 When properly set, the LUID is an integer that numbers each insn in
283 the basic block, in order from the start of the block.
284 The numbers are only correct after a call to df_analyze. They will
285 rot after insns are added deleted or moved round.
287 ACCESSING REFS:
289 There are 4 ways to obtain access to refs:
291 1) References are divided into two categories, REAL and ARTIFICIAL.
293 REAL refs are associated with instructions.
295 ARTIFICIAL refs are associated with basic blocks. The heads of
296 these lists can be accessed by calling df_get_artificial_defs or
297 df_get_artificial_uses for the particular basic block.
299 Artificial defs and uses occur both at the beginning and ends of blocks.
301 For blocks that area at the destination of eh edges, the
302 artificial uses and defs occur at the beginning. The defs relate
303 to the registers specified in EH_RETURN_DATA_REGNO and the uses
304 relate to the registers specified in ED_USES. Logically these
305 defs and uses should really occur along the eh edge, but there is
306 no convenient way to do this. Artificial edges that occur at the
307 beginning of the block have the DF_REF_AT_TOP flag set.
309 Artificial uses occur at the end of all blocks. These arise from
310 the hard registers that are always live, such as the stack
311 register and are put there to keep the code from forgetting about
312 them.
314 Artificial defs occur at the end of the entry block. These arise
315 from registers that are live at entry to the function.
317 2) There are three types of refs: defs, uses and eq_uses. (Eq_uses are
318 uses that appear inside a REG_EQUAL or REG_EQUIV note.)
320 All of the eq_uses, uses and defs associated with each pseudo or
321 hard register may be linked in a bidirectional chain. These are
322 called reg-use or reg_def chains. If the changeable flag
323 DF_EQ_NOTES is set when the chains are built, the eq_uses will be
324 treated like uses. If it is not set they are ignored.
326 The first use, eq_use or def for a register can be obtained using
327 the DF_REG_USE_CHAIN, DF_REG_EQ_USE_CHAIN or DF_REG_DEF_CHAIN
328 macros. Subsequent uses for the same regno can be obtained by
329 following the next_reg field of the ref. The number of elements in
330 each of the chains can be found by using the DF_REG_USE_COUNT,
331 DF_REG_EQ_USE_COUNT or DF_REG_DEF_COUNT macros.
333 In previous versions of this code, these chains were ordered. It
334 has not been practical to continue this practice.
336 3) If def-use or use-def chains are built, these can be traversed to
337 get to other refs. If the flag DF_EQ_NOTES has been set, the chains
338 include the eq_uses. Otherwise these are ignored when building the
339 chains.
341 4) An array of all of the uses (and an array of all of the defs) can
342 be built. These arrays are indexed by the value in the id
343 structure. These arrays are only lazily kept up to date, and that
344 process can be expensive. To have these arrays built, call
345 df_reorganize_defs or df_reorganize_uses. If the flag DF_EQ_NOTES
346 has been set the array will contain the eq_uses. Otherwise these
347 are ignored when building the array and assigning the ids. Note
348 that the values in the id field of a ref may change across calls to
349 df_analyze or df_reorganize_defs or df_reorganize_uses.
351 If the only use of this array is to find all of the refs, it is
352 better to traverse all of the registers and then traverse all of
353 reg-use or reg-def chains.
355 NOTES:
357 Embedded addressing side-effects, such as POST_INC or PRE_INC, generate
358 both a use and a def. These are both marked read/write to show that they
359 are dependent. For example, (set (reg 40) (mem (post_inc (reg 42))))
360 will generate a use of reg 42 followed by a def of reg 42 (both marked
361 read/write). Similarly, (set (reg 40) (mem (pre_dec (reg 41))))
362 generates a use of reg 41 then a def of reg 41 (both marked read/write),
363 even though reg 41 is decremented before it is used for the memory
364 address in this second example.
366 A set to a REG inside a ZERO_EXTRACT, or a set to a non-paradoxical SUBREG
367 for which the number of word_mode units covered by the outer mode is
368 smaller than that covered by the inner mode, invokes a read-modify-write
369 operation. We generate both a use and a def and again mark them
370 read/write.
372 Paradoxical subreg writes do not leave a trace of the old content, so they
373 are write-only operations.
377 #include "config.h"
378 #include "system.h"
379 #include "coretypes.h"
380 #include "tm.h"
381 #include "rtl.h"
382 #include "tm_p.h"
383 #include "insn-config.h"
384 #include "recog.h"
385 #include "function.h"
386 #include "regs.h"
387 #include "alloc-pool.h"
388 #include "flags.h"
389 #include "hard-reg-set.h"
390 #include "basic-block.h"
391 #include "sbitmap.h"
392 #include "bitmap.h"
393 #include "df.h"
394 #include "tree-pass.h"
395 #include "params.h"
397 static void *df_get_bb_info (struct dataflow *, unsigned int);
398 static void df_set_bb_info (struct dataflow *, unsigned int, void *);
399 static void df_clear_bb_info (struct dataflow *, unsigned int);
400 #ifdef DF_DEBUG_CFG
401 static void df_set_clean_cfg (void);
402 #endif
404 /* The obstack on which regsets are allocated. */
405 struct bitmap_obstack reg_obstack;
407 /* An obstack for bitmap not related to specific dataflow problems.
408 This obstack should e.g. be used for bitmaps with a short life time
409 such as temporary bitmaps. */
411 bitmap_obstack df_bitmap_obstack;
414 /*----------------------------------------------------------------------------
415 Functions to create, destroy and manipulate an instance of df.
416 ----------------------------------------------------------------------------*/
418 struct df_d *df;
420 /* Add PROBLEM (and any dependent problems) to the DF instance. */
422 void
423 df_add_problem (struct df_problem *problem)
425 struct dataflow *dflow;
426 int i;
428 /* First try to add the dependent problem. */
429 if (problem->dependent_problem)
430 df_add_problem (problem->dependent_problem);
432 /* Check to see if this problem has already been defined. If it
433 has, just return that instance, if not, add it to the end of the
434 vector. */
435 dflow = df->problems_by_index[problem->id];
436 if (dflow)
437 return;
439 /* Make a new one and add it to the end. */
440 dflow = XCNEW (struct dataflow);
441 dflow->problem = problem;
442 dflow->computed = false;
443 dflow->solutions_dirty = true;
444 df->problems_by_index[dflow->problem->id] = dflow;
446 /* Keep the defined problems ordered by index. This solves the
447 problem that RI will use the information from UREC if UREC has
448 been defined, or from LIVE if LIVE is defined and otherwise LR.
449 However for this to work, the computation of RI must be pushed
450 after which ever of those problems is defined, but we do not
451 require any of those except for LR to have actually been
452 defined. */
453 df->num_problems_defined++;
454 for (i = df->num_problems_defined - 2; i >= 0; i--)
456 if (problem->id < df->problems_in_order[i]->problem->id)
457 df->problems_in_order[i+1] = df->problems_in_order[i];
458 else
460 df->problems_in_order[i+1] = dflow;
461 return;
464 df->problems_in_order[0] = dflow;
468 /* Set the MASK flags in the DFLOW problem. The old flags are
469 returned. If a flag is not allowed to be changed this will fail if
470 checking is enabled. */
472 df_set_flags (int changeable_flags)
474 int old_flags = df->changeable_flags;
475 df->changeable_flags |= changeable_flags;
476 return old_flags;
480 /* Clear the MASK flags in the DFLOW problem. The old flags are
481 returned. If a flag is not allowed to be changed this will fail if
482 checking is enabled. */
484 df_clear_flags (int changeable_flags)
486 int old_flags = df->changeable_flags;
487 df->changeable_flags &= ~changeable_flags;
488 return old_flags;
492 /* Set the blocks that are to be considered for analysis. If this is
493 not called or is called with null, the entire function in
494 analyzed. */
496 void
497 df_set_blocks (bitmap blocks)
499 if (blocks)
501 if (dump_file)
502 bitmap_print (dump_file, blocks, "setting blocks to analyze ", "\n");
503 if (df->blocks_to_analyze)
505 /* This block is called to change the focus from one subset
506 to another. */
507 int p;
508 bitmap_head diff;
509 bitmap_initialize (&diff, &df_bitmap_obstack);
510 bitmap_and_compl (&diff, df->blocks_to_analyze, blocks);
511 for (p = 0; p < df->num_problems_defined; p++)
513 struct dataflow *dflow = df->problems_in_order[p];
514 if (dflow->optional_p && dflow->problem->reset_fun)
515 dflow->problem->reset_fun (df->blocks_to_analyze);
516 else if (dflow->problem->free_blocks_on_set_blocks)
518 bitmap_iterator bi;
519 unsigned int bb_index;
521 EXECUTE_IF_SET_IN_BITMAP (&diff, 0, bb_index, bi)
523 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
524 if (bb)
526 void *bb_info = df_get_bb_info (dflow, bb_index);
527 dflow->problem->free_bb_fun (bb, bb_info);
528 df_clear_bb_info (dflow, bb_index);
534 bitmap_clear (&diff);
536 else
538 /* This block of code is executed to change the focus from
539 the entire function to a subset. */
540 bitmap_head blocks_to_reset;
541 bool initialized = false;
542 int p;
543 for (p = 0; p < df->num_problems_defined; p++)
545 struct dataflow *dflow = df->problems_in_order[p];
546 if (dflow->optional_p && dflow->problem->reset_fun)
548 if (!initialized)
550 basic_block bb;
551 bitmap_initialize (&blocks_to_reset, &df_bitmap_obstack);
552 FOR_ALL_BB_FN (bb, cfun)
554 bitmap_set_bit (&blocks_to_reset, bb->index);
557 dflow->problem->reset_fun (&blocks_to_reset);
560 if (initialized)
561 bitmap_clear (&blocks_to_reset);
563 df->blocks_to_analyze = BITMAP_ALLOC (&df_bitmap_obstack);
565 bitmap_copy (df->blocks_to_analyze, blocks);
566 df->analyze_subset = true;
568 else
570 /* This block is executed to reset the focus to the entire
571 function. */
572 if (dump_file)
573 fprintf (dump_file, "clearing blocks_to_analyze\n");
574 if (df->blocks_to_analyze)
576 BITMAP_FREE (df->blocks_to_analyze);
577 df->blocks_to_analyze = NULL;
579 df->analyze_subset = false;
582 /* Setting the blocks causes the refs to be unorganized since only
583 the refs in the blocks are seen. */
584 df_maybe_reorganize_def_refs (DF_REF_ORDER_NO_TABLE);
585 df_maybe_reorganize_use_refs (DF_REF_ORDER_NO_TABLE);
586 df_mark_solutions_dirty ();
590 /* Delete a DFLOW problem (and any problems that depend on this
591 problem). */
593 void
594 df_remove_problem (struct dataflow *dflow)
596 struct df_problem *problem;
597 int i;
599 if (!dflow)
600 return;
602 problem = dflow->problem;
603 gcc_assert (problem->remove_problem_fun);
605 /* Delete any problems that depended on this problem first. */
606 for (i = 0; i < df->num_problems_defined; i++)
607 if (df->problems_in_order[i]->problem->dependent_problem == problem)
608 df_remove_problem (df->problems_in_order[i]);
610 /* Now remove this problem. */
611 for (i = 0; i < df->num_problems_defined; i++)
612 if (df->problems_in_order[i] == dflow)
614 int j;
615 for (j = i + 1; j < df->num_problems_defined; j++)
616 df->problems_in_order[j-1] = df->problems_in_order[j];
617 df->problems_in_order[j-1] = NULL;
618 df->num_problems_defined--;
619 break;
622 (problem->remove_problem_fun) ();
623 df->problems_by_index[problem->id] = NULL;
627 /* Remove all of the problems that are not permanent. Scanning, LR
628 and (at -O2 or higher) LIVE are permanent, the rest are removable.
629 Also clear all of the changeable_flags. */
631 void
632 df_finish_pass (bool verify ATTRIBUTE_UNUSED)
634 int i;
635 int removed = 0;
637 #ifdef ENABLE_DF_CHECKING
638 int saved_flags;
639 #endif
641 if (!df)
642 return;
644 df_maybe_reorganize_def_refs (DF_REF_ORDER_NO_TABLE);
645 df_maybe_reorganize_use_refs (DF_REF_ORDER_NO_TABLE);
647 #ifdef ENABLE_DF_CHECKING
648 saved_flags = df->changeable_flags;
649 #endif
651 for (i = 0; i < df->num_problems_defined; i++)
653 struct dataflow *dflow = df->problems_in_order[i];
654 struct df_problem *problem = dflow->problem;
656 if (dflow->optional_p)
658 gcc_assert (problem->remove_problem_fun);
659 (problem->remove_problem_fun) ();
660 df->problems_in_order[i] = NULL;
661 df->problems_by_index[problem->id] = NULL;
662 removed++;
665 df->num_problems_defined -= removed;
667 /* Clear all of the flags. */
668 df->changeable_flags = 0;
669 df_process_deferred_rescans ();
671 /* Set the focus back to the whole function. */
672 if (df->blocks_to_analyze)
674 BITMAP_FREE (df->blocks_to_analyze);
675 df->blocks_to_analyze = NULL;
676 df_mark_solutions_dirty ();
677 df->analyze_subset = false;
680 #ifdef ENABLE_DF_CHECKING
681 /* Verification will fail in DF_NO_INSN_RESCAN. */
682 if (!(saved_flags & DF_NO_INSN_RESCAN))
684 df_lr_verify_transfer_functions ();
685 if (df_live)
686 df_live_verify_transfer_functions ();
689 #ifdef DF_DEBUG_CFG
690 df_set_clean_cfg ();
691 #endif
692 #endif
694 #ifdef ENABLE_CHECKING
695 if (verify)
696 df->changeable_flags |= DF_VERIFY_SCHEDULED;
697 #endif
701 /* Set up the dataflow instance for the entire back end. */
703 static unsigned int
704 rest_of_handle_df_initialize (void)
706 gcc_assert (!df);
707 df = XCNEW (struct df_d);
708 df->changeable_flags = 0;
710 bitmap_obstack_initialize (&df_bitmap_obstack);
712 /* Set this to a conservative value. Stack_ptr_mod will compute it
713 correctly later. */
714 crtl->sp_is_unchanging = 0;
716 df_scan_add_problem ();
717 df_scan_alloc (NULL);
719 /* These three problems are permanent. */
720 df_lr_add_problem ();
721 if (optimize > 1)
722 df_live_add_problem ();
724 df->postorder = XNEWVEC (int, last_basic_block_for_fn (cfun));
725 df->postorder_inverted = XNEWVEC (int, last_basic_block_for_fn (cfun));
726 df->n_blocks = post_order_compute (df->postorder, true, true);
727 df->n_blocks_inverted = inverted_post_order_compute (df->postorder_inverted);
728 gcc_assert (df->n_blocks == df->n_blocks_inverted);
730 df->hard_regs_live_count = XCNEWVEC (unsigned int, FIRST_PSEUDO_REGISTER);
732 df_hard_reg_init ();
733 /* After reload, some ports add certain bits to regs_ever_live so
734 this cannot be reset. */
735 df_compute_regs_ever_live (true);
736 df_scan_blocks ();
737 df_compute_regs_ever_live (false);
738 return 0;
742 static bool
743 gate_opt (void)
745 return optimize > 0;
749 namespace {
751 const pass_data pass_data_df_initialize_opt =
753 RTL_PASS, /* type */
754 "dfinit", /* name */
755 OPTGROUP_NONE, /* optinfo_flags */
756 true, /* has_gate */
757 true, /* has_execute */
758 TV_DF_SCAN, /* tv_id */
759 0, /* properties_required */
760 0, /* properties_provided */
761 0, /* properties_destroyed */
762 0, /* todo_flags_start */
763 0, /* todo_flags_finish */
766 class pass_df_initialize_opt : public rtl_opt_pass
768 public:
769 pass_df_initialize_opt (gcc::context *ctxt)
770 : rtl_opt_pass (pass_data_df_initialize_opt, ctxt)
773 /* opt_pass methods: */
774 bool gate () { return gate_opt (); }
775 unsigned int execute () { return rest_of_handle_df_initialize (); }
777 }; // class pass_df_initialize_opt
779 } // anon namespace
781 rtl_opt_pass *
782 make_pass_df_initialize_opt (gcc::context *ctxt)
784 return new pass_df_initialize_opt (ctxt);
788 static bool
789 gate_no_opt (void)
791 return optimize == 0;
795 namespace {
797 const pass_data pass_data_df_initialize_no_opt =
799 RTL_PASS, /* type */
800 "no-opt dfinit", /* name */
801 OPTGROUP_NONE, /* optinfo_flags */
802 true, /* has_gate */
803 true, /* has_execute */
804 TV_DF_SCAN, /* tv_id */
805 0, /* properties_required */
806 0, /* properties_provided */
807 0, /* properties_destroyed */
808 0, /* todo_flags_start */
809 0, /* todo_flags_finish */
812 class pass_df_initialize_no_opt : public rtl_opt_pass
814 public:
815 pass_df_initialize_no_opt (gcc::context *ctxt)
816 : rtl_opt_pass (pass_data_df_initialize_no_opt, ctxt)
819 /* opt_pass methods: */
820 bool gate () { return gate_no_opt (); }
821 unsigned int execute () { return rest_of_handle_df_initialize (); }
823 }; // class pass_df_initialize_no_opt
825 } // anon namespace
827 rtl_opt_pass *
828 make_pass_df_initialize_no_opt (gcc::context *ctxt)
830 return new pass_df_initialize_no_opt (ctxt);
834 /* Free all the dataflow info and the DF structure. This should be
835 called from the df_finish macro which also NULLs the parm. */
837 static unsigned int
838 rest_of_handle_df_finish (void)
840 int i;
842 gcc_assert (df);
844 for (i = 0; i < df->num_problems_defined; i++)
846 struct dataflow *dflow = df->problems_in_order[i];
847 dflow->problem->free_fun ();
850 free (df->postorder);
851 free (df->postorder_inverted);
852 free (df->hard_regs_live_count);
853 free (df);
854 df = NULL;
856 bitmap_obstack_release (&df_bitmap_obstack);
857 return 0;
861 namespace {
863 const pass_data pass_data_df_finish =
865 RTL_PASS, /* type */
866 "dfinish", /* name */
867 OPTGROUP_NONE, /* optinfo_flags */
868 false, /* has_gate */
869 true, /* has_execute */
870 TV_NONE, /* tv_id */
871 0, /* properties_required */
872 0, /* properties_provided */
873 0, /* properties_destroyed */
874 0, /* todo_flags_start */
875 0, /* todo_flags_finish */
878 class pass_df_finish : public rtl_opt_pass
880 public:
881 pass_df_finish (gcc::context *ctxt)
882 : rtl_opt_pass (pass_data_df_finish, ctxt)
885 /* opt_pass methods: */
886 unsigned int execute () { return rest_of_handle_df_finish (); }
888 }; // class pass_df_finish
890 } // anon namespace
892 rtl_opt_pass *
893 make_pass_df_finish (gcc::context *ctxt)
895 return new pass_df_finish (ctxt);
902 /*----------------------------------------------------------------------------
903 The general data flow analysis engine.
904 ----------------------------------------------------------------------------*/
906 /* Return time BB when it was visited for last time. */
907 #define BB_LAST_CHANGE_AGE(bb) ((ptrdiff_t)(bb)->aux)
909 /* Helper function for df_worklist_dataflow.
910 Propagate the dataflow forward.
911 Given a BB_INDEX, do the dataflow propagation
912 and set bits on for successors in PENDING
913 if the out set of the dataflow has changed.
915 AGE specify time when BB was visited last time.
916 AGE of 0 means we are visiting for first time and need to
917 compute transfer function to initialize datastructures.
918 Otherwise we re-do transfer function only if something change
919 while computing confluence functions.
920 We need to compute confluence only of basic block that are younger
921 then last visit of the BB.
923 Return true if BB info has changed. This is always the case
924 in the first visit. */
926 static bool
927 df_worklist_propagate_forward (struct dataflow *dataflow,
928 unsigned bb_index,
929 unsigned *bbindex_to_postorder,
930 bitmap pending,
931 sbitmap considered,
932 ptrdiff_t age)
934 edge e;
935 edge_iterator ei;
936 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
937 bool changed = !age;
939 /* Calculate <conf_op> of incoming edges. */
940 if (EDGE_COUNT (bb->preds) > 0)
941 FOR_EACH_EDGE (e, ei, bb->preds)
943 if (age <= BB_LAST_CHANGE_AGE (e->src)
944 && bitmap_bit_p (considered, e->src->index))
945 changed |= dataflow->problem->con_fun_n (e);
947 else if (dataflow->problem->con_fun_0)
948 dataflow->problem->con_fun_0 (bb);
950 if (changed
951 && dataflow->problem->trans_fun (bb_index))
953 /* The out set of this block has changed.
954 Propagate to the outgoing blocks. */
955 FOR_EACH_EDGE (e, ei, bb->succs)
957 unsigned ob_index = e->dest->index;
959 if (bitmap_bit_p (considered, ob_index))
960 bitmap_set_bit (pending, bbindex_to_postorder[ob_index]);
962 return true;
964 return false;
968 /* Helper function for df_worklist_dataflow.
969 Propagate the dataflow backward. */
971 static bool
972 df_worklist_propagate_backward (struct dataflow *dataflow,
973 unsigned bb_index,
974 unsigned *bbindex_to_postorder,
975 bitmap pending,
976 sbitmap considered,
977 ptrdiff_t age)
979 edge e;
980 edge_iterator ei;
981 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
982 bool changed = !age;
984 /* Calculate <conf_op> of incoming edges. */
985 if (EDGE_COUNT (bb->succs) > 0)
986 FOR_EACH_EDGE (e, ei, bb->succs)
988 if (age <= BB_LAST_CHANGE_AGE (e->dest)
989 && bitmap_bit_p (considered, e->dest->index))
990 changed |= dataflow->problem->con_fun_n (e);
992 else if (dataflow->problem->con_fun_0)
993 dataflow->problem->con_fun_0 (bb);
995 if (changed
996 && dataflow->problem->trans_fun (bb_index))
998 /* The out set of this block has changed.
999 Propagate to the outgoing blocks. */
1000 FOR_EACH_EDGE (e, ei, bb->preds)
1002 unsigned ob_index = e->src->index;
1004 if (bitmap_bit_p (considered, ob_index))
1005 bitmap_set_bit (pending, bbindex_to_postorder[ob_index]);
1007 return true;
1009 return false;
1012 /* Main dataflow solver loop.
1014 DATAFLOW is problem we are solving, PENDING is worklist of basic blocks we
1015 need to visit.
1016 BLOCK_IN_POSTORDER is array of size N_BLOCKS specifying postorder in BBs and
1017 BBINDEX_TO_POSTORDER is array mapping back BB->index to postorder position.
1018 PENDING will be freed.
1020 The worklists are bitmaps indexed by postorder positions.
1022 The function implements standard algorithm for dataflow solving with two
1023 worklists (we are processing WORKLIST and storing new BBs to visit in
1024 PENDING).
1026 As an optimization we maintain ages when BB was changed (stored in bb->aux)
1027 and when it was last visited (stored in last_visit_age). This avoids need
1028 to re-do confluence function for edges to basic blocks whose source
1029 did not change since destination was visited last time. */
1031 static void
1032 df_worklist_dataflow_doublequeue (struct dataflow *dataflow,
1033 bitmap pending,
1034 sbitmap considered,
1035 int *blocks_in_postorder,
1036 unsigned *bbindex_to_postorder,
1037 int n_blocks)
1039 enum df_flow_dir dir = dataflow->problem->dir;
1040 int dcount = 0;
1041 bitmap worklist = BITMAP_ALLOC (&df_bitmap_obstack);
1042 int age = 0;
1043 bool changed;
1044 vec<int> last_visit_age = vNULL;
1045 int prev_age;
1046 basic_block bb;
1047 int i;
1049 last_visit_age.safe_grow_cleared (n_blocks);
1051 /* Double-queueing. Worklist is for the current iteration,
1052 and pending is for the next. */
1053 while (!bitmap_empty_p (pending))
1055 bitmap_iterator bi;
1056 unsigned int index;
1058 /* Swap pending and worklist. */
1059 bitmap temp = worklist;
1060 worklist = pending;
1061 pending = temp;
1063 EXECUTE_IF_SET_IN_BITMAP (worklist, 0, index, bi)
1065 unsigned bb_index;
1066 dcount++;
1068 bitmap_clear_bit (pending, index);
1069 bb_index = blocks_in_postorder[index];
1070 bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
1071 prev_age = last_visit_age[index];
1072 if (dir == DF_FORWARD)
1073 changed = df_worklist_propagate_forward (dataflow, bb_index,
1074 bbindex_to_postorder,
1075 pending, considered,
1076 prev_age);
1077 else
1078 changed = df_worklist_propagate_backward (dataflow, bb_index,
1079 bbindex_to_postorder,
1080 pending, considered,
1081 prev_age);
1082 last_visit_age[index] = ++age;
1083 if (changed)
1084 bb->aux = (void *)(ptrdiff_t)age;
1086 bitmap_clear (worklist);
1088 for (i = 0; i < n_blocks; i++)
1089 BASIC_BLOCK_FOR_FN (cfun, blocks_in_postorder[i])->aux = NULL;
1091 BITMAP_FREE (worklist);
1092 BITMAP_FREE (pending);
1093 last_visit_age.release ();
1095 /* Dump statistics. */
1096 if (dump_file)
1097 fprintf (dump_file, "df_worklist_dataflow_doublequeue:"
1098 "n_basic_blocks %d n_edges %d"
1099 " count %d (%5.2g)\n",
1100 n_basic_blocks_for_fn (cfun), n_edges_for_fn (cfun),
1101 dcount, dcount / (float)n_basic_blocks_for_fn (cfun));
1104 /* Worklist-based dataflow solver. It uses sbitmap as a worklist,
1105 with "n"-th bit representing the n-th block in the reverse-postorder order.
1106 The solver is a double-queue algorithm similar to the "double stack" solver
1107 from Cooper, Harvey and Kennedy, "Iterative data-flow analysis, Revisited".
1108 The only significant difference is that the worklist in this implementation
1109 is always sorted in RPO of the CFG visiting direction. */
1111 void
1112 df_worklist_dataflow (struct dataflow *dataflow,
1113 bitmap blocks_to_consider,
1114 int *blocks_in_postorder,
1115 int n_blocks)
1117 bitmap pending = BITMAP_ALLOC (&df_bitmap_obstack);
1118 sbitmap considered = sbitmap_alloc (last_basic_block_for_fn (cfun));
1119 bitmap_iterator bi;
1120 unsigned int *bbindex_to_postorder;
1121 int i;
1122 unsigned int index;
1123 enum df_flow_dir dir = dataflow->problem->dir;
1125 gcc_assert (dir != DF_NONE);
1127 /* BBINDEX_TO_POSTORDER maps the bb->index to the reverse postorder. */
1128 bbindex_to_postorder = XNEWVEC (unsigned int,
1129 last_basic_block_for_fn (cfun));
1131 /* Initialize the array to an out-of-bound value. */
1132 for (i = 0; i < last_basic_block_for_fn (cfun); i++)
1133 bbindex_to_postorder[i] = last_basic_block_for_fn (cfun);
1135 /* Initialize the considered map. */
1136 bitmap_clear (considered);
1137 EXECUTE_IF_SET_IN_BITMAP (blocks_to_consider, 0, index, bi)
1139 bitmap_set_bit (considered, index);
1142 /* Initialize the mapping of block index to postorder. */
1143 for (i = 0; i < n_blocks; i++)
1145 bbindex_to_postorder[blocks_in_postorder[i]] = i;
1146 /* Add all blocks to the worklist. */
1147 bitmap_set_bit (pending, i);
1150 /* Initialize the problem. */
1151 if (dataflow->problem->init_fun)
1152 dataflow->problem->init_fun (blocks_to_consider);
1154 /* Solve it. */
1155 df_worklist_dataflow_doublequeue (dataflow, pending, considered,
1156 blocks_in_postorder,
1157 bbindex_to_postorder,
1158 n_blocks);
1159 sbitmap_free (considered);
1160 free (bbindex_to_postorder);
1164 /* Remove the entries not in BLOCKS from the LIST of length LEN, preserving
1165 the order of the remaining entries. Returns the length of the resulting
1166 list. */
1168 static unsigned
1169 df_prune_to_subcfg (int list[], unsigned len, bitmap blocks)
1171 unsigned act, last;
1173 for (act = 0, last = 0; act < len; act++)
1174 if (bitmap_bit_p (blocks, list[act]))
1175 list[last++] = list[act];
1177 return last;
1181 /* Execute dataflow analysis on a single dataflow problem.
1183 BLOCKS_TO_CONSIDER are the blocks whose solution can either be
1184 examined or will be computed. For calls from DF_ANALYZE, this is
1185 the set of blocks that has been passed to DF_SET_BLOCKS.
1188 void
1189 df_analyze_problem (struct dataflow *dflow,
1190 bitmap blocks_to_consider,
1191 int *postorder, int n_blocks)
1193 timevar_push (dflow->problem->tv_id);
1195 /* (Re)Allocate the datastructures necessary to solve the problem. */
1196 if (dflow->problem->alloc_fun)
1197 dflow->problem->alloc_fun (blocks_to_consider);
1199 #ifdef ENABLE_DF_CHECKING
1200 if (dflow->problem->verify_start_fun)
1201 dflow->problem->verify_start_fun ();
1202 #endif
1204 /* Set up the problem and compute the local information. */
1205 if (dflow->problem->local_compute_fun)
1206 dflow->problem->local_compute_fun (blocks_to_consider);
1208 /* Solve the equations. */
1209 if (dflow->problem->dataflow_fun)
1210 dflow->problem->dataflow_fun (dflow, blocks_to_consider,
1211 postorder, n_blocks);
1213 /* Massage the solution. */
1214 if (dflow->problem->finalize_fun)
1215 dflow->problem->finalize_fun (blocks_to_consider);
1217 #ifdef ENABLE_DF_CHECKING
1218 if (dflow->problem->verify_end_fun)
1219 dflow->problem->verify_end_fun ();
1220 #endif
1222 timevar_pop (dflow->problem->tv_id);
1224 dflow->computed = true;
1228 /* Analyze dataflow info for the basic blocks specified by the bitmap
1229 BLOCKS, or for the whole CFG if BLOCKS is zero. */
1231 void
1232 df_analyze (void)
1234 bitmap current_all_blocks = BITMAP_ALLOC (&df_bitmap_obstack);
1235 bool everything;
1236 int i;
1238 free (df->postorder);
1239 free (df->postorder_inverted);
1240 df->postorder = XNEWVEC (int, last_basic_block_for_fn (cfun));
1241 df->postorder_inverted = XNEWVEC (int, last_basic_block_for_fn (cfun));
1242 df->n_blocks = post_order_compute (df->postorder, true, true);
1243 df->n_blocks_inverted = inverted_post_order_compute (df->postorder_inverted);
1245 /* These should be the same. */
1246 gcc_assert (df->n_blocks == df->n_blocks_inverted);
1248 /* We need to do this before the df_verify_all because this is
1249 not kept incrementally up to date. */
1250 df_compute_regs_ever_live (false);
1251 df_process_deferred_rescans ();
1253 if (dump_file)
1254 fprintf (dump_file, "df_analyze called\n");
1256 #ifndef ENABLE_DF_CHECKING
1257 if (df->changeable_flags & DF_VERIFY_SCHEDULED)
1258 #endif
1259 df_verify ();
1261 for (i = 0; i < df->n_blocks; i++)
1262 bitmap_set_bit (current_all_blocks, df->postorder[i]);
1264 #ifdef ENABLE_CHECKING
1265 /* Verify that POSTORDER_INVERTED only contains blocks reachable from
1266 the ENTRY block. */
1267 for (i = 0; i < df->n_blocks_inverted; i++)
1268 gcc_assert (bitmap_bit_p (current_all_blocks, df->postorder_inverted[i]));
1269 #endif
1271 /* Make sure that we have pruned any unreachable blocks from these
1272 sets. */
1273 if (df->analyze_subset)
1275 everything = false;
1276 bitmap_and_into (df->blocks_to_analyze, current_all_blocks);
1277 df->n_blocks = df_prune_to_subcfg (df->postorder,
1278 df->n_blocks, df->blocks_to_analyze);
1279 df->n_blocks_inverted = df_prune_to_subcfg (df->postorder_inverted,
1280 df->n_blocks_inverted,
1281 df->blocks_to_analyze);
1282 BITMAP_FREE (current_all_blocks);
1284 else
1286 everything = true;
1287 df->blocks_to_analyze = current_all_blocks;
1288 current_all_blocks = NULL;
1291 /* Skip over the DF_SCAN problem. */
1292 for (i = 1; i < df->num_problems_defined; i++)
1294 struct dataflow *dflow = df->problems_in_order[i];
1295 if (dflow->solutions_dirty)
1297 if (dflow->problem->dir == DF_FORWARD)
1298 df_analyze_problem (dflow,
1299 df->blocks_to_analyze,
1300 df->postorder_inverted,
1301 df->n_blocks_inverted);
1302 else
1303 df_analyze_problem (dflow,
1304 df->blocks_to_analyze,
1305 df->postorder,
1306 df->n_blocks);
1310 if (everything)
1312 BITMAP_FREE (df->blocks_to_analyze);
1313 df->blocks_to_analyze = NULL;
1316 #ifdef DF_DEBUG_CFG
1317 df_set_clean_cfg ();
1318 #endif
1322 /* Return the number of basic blocks from the last call to df_analyze. */
1325 df_get_n_blocks (enum df_flow_dir dir)
1327 gcc_assert (dir != DF_NONE);
1329 if (dir == DF_FORWARD)
1331 gcc_assert (df->postorder_inverted);
1332 return df->n_blocks_inverted;
1335 gcc_assert (df->postorder);
1336 return df->n_blocks;
1340 /* Return a pointer to the array of basic blocks in the reverse postorder.
1341 Depending on the direction of the dataflow problem,
1342 it returns either the usual reverse postorder array
1343 or the reverse postorder of inverted traversal. */
1344 int *
1345 df_get_postorder (enum df_flow_dir dir)
1347 gcc_assert (dir != DF_NONE);
1349 if (dir == DF_FORWARD)
1351 gcc_assert (df->postorder_inverted);
1352 return df->postorder_inverted;
1354 gcc_assert (df->postorder);
1355 return df->postorder;
1358 static struct df_problem user_problem;
1359 static struct dataflow user_dflow;
1361 /* Interface for calling iterative dataflow with user defined
1362 confluence and transfer functions. All that is necessary is to
1363 supply DIR, a direction, CONF_FUN_0, a confluence function for
1364 blocks with no logical preds (or NULL), CONF_FUN_N, the normal
1365 confluence function, TRANS_FUN, the basic block transfer function,
1366 and BLOCKS, the set of blocks to examine, POSTORDER the blocks in
1367 postorder, and N_BLOCKS, the number of blocks in POSTORDER. */
1369 void
1370 df_simple_dataflow (enum df_flow_dir dir,
1371 df_init_function init_fun,
1372 df_confluence_function_0 con_fun_0,
1373 df_confluence_function_n con_fun_n,
1374 df_transfer_function trans_fun,
1375 bitmap blocks, int * postorder, int n_blocks)
1377 memset (&user_problem, 0, sizeof (struct df_problem));
1378 user_problem.dir = dir;
1379 user_problem.init_fun = init_fun;
1380 user_problem.con_fun_0 = con_fun_0;
1381 user_problem.con_fun_n = con_fun_n;
1382 user_problem.trans_fun = trans_fun;
1383 user_dflow.problem = &user_problem;
1384 df_worklist_dataflow (&user_dflow, blocks, postorder, n_blocks);
1389 /*----------------------------------------------------------------------------
1390 Functions to support limited incremental change.
1391 ----------------------------------------------------------------------------*/
1394 /* Get basic block info. */
1396 static void *
1397 df_get_bb_info (struct dataflow *dflow, unsigned int index)
1399 if (dflow->block_info == NULL)
1400 return NULL;
1401 if (index >= dflow->block_info_size)
1402 return NULL;
1403 return (void *)((char *)dflow->block_info
1404 + index * dflow->problem->block_info_elt_size);
1408 /* Set basic block info. */
1410 static void
1411 df_set_bb_info (struct dataflow *dflow, unsigned int index,
1412 void *bb_info)
1414 gcc_assert (dflow->block_info);
1415 memcpy ((char *)dflow->block_info
1416 + index * dflow->problem->block_info_elt_size,
1417 bb_info, dflow->problem->block_info_elt_size);
1421 /* Clear basic block info. */
1423 static void
1424 df_clear_bb_info (struct dataflow *dflow, unsigned int index)
1426 gcc_assert (dflow->block_info);
1427 gcc_assert (dflow->block_info_size > index);
1428 memset ((char *)dflow->block_info
1429 + index * dflow->problem->block_info_elt_size,
1430 0, dflow->problem->block_info_elt_size);
1434 /* Mark the solutions as being out of date. */
1436 void
1437 df_mark_solutions_dirty (void)
1439 if (df)
1441 int p;
1442 for (p = 1; p < df->num_problems_defined; p++)
1443 df->problems_in_order[p]->solutions_dirty = true;
1448 /* Return true if BB needs it's transfer functions recomputed. */
1450 bool
1451 df_get_bb_dirty (basic_block bb)
1453 return bitmap_bit_p ((df_live
1454 ? df_live : df_lr)->out_of_date_transfer_functions,
1455 bb->index);
1459 /* Mark BB as needing it's transfer functions as being out of
1460 date. */
1462 void
1463 df_set_bb_dirty (basic_block bb)
1465 bb->flags |= BB_MODIFIED;
1466 if (df)
1468 int p;
1469 for (p = 1; p < df->num_problems_defined; p++)
1471 struct dataflow *dflow = df->problems_in_order[p];
1472 if (dflow->out_of_date_transfer_functions)
1473 bitmap_set_bit (dflow->out_of_date_transfer_functions, bb->index);
1475 df_mark_solutions_dirty ();
1480 /* Grow the bb_info array. */
1482 void
1483 df_grow_bb_info (struct dataflow *dflow)
1485 unsigned int new_size = last_basic_block_for_fn (cfun) + 1;
1486 if (dflow->block_info_size < new_size)
1488 new_size += new_size / 4;
1489 dflow->block_info
1490 = (void *)XRESIZEVEC (char, (char *)dflow->block_info,
1491 new_size
1492 * dflow->problem->block_info_elt_size);
1493 memset ((char *)dflow->block_info
1494 + dflow->block_info_size
1495 * dflow->problem->block_info_elt_size,
1497 (new_size - dflow->block_info_size)
1498 * dflow->problem->block_info_elt_size);
1499 dflow->block_info_size = new_size;
1504 /* Clear the dirty bits. This is called from places that delete
1505 blocks. */
1506 static void
1507 df_clear_bb_dirty (basic_block bb)
1509 int p;
1510 for (p = 1; p < df->num_problems_defined; p++)
1512 struct dataflow *dflow = df->problems_in_order[p];
1513 if (dflow->out_of_date_transfer_functions)
1514 bitmap_clear_bit (dflow->out_of_date_transfer_functions, bb->index);
1518 /* Called from the rtl_compact_blocks to reorganize the problems basic
1519 block info. */
1521 void
1522 df_compact_blocks (void)
1524 int i, p;
1525 basic_block bb;
1526 void *problem_temps;
1527 bitmap_head tmp;
1529 bitmap_initialize (&tmp, &df_bitmap_obstack);
1530 for (p = 0; p < df->num_problems_defined; p++)
1532 struct dataflow *dflow = df->problems_in_order[p];
1534 /* Need to reorganize the out_of_date_transfer_functions for the
1535 dflow problem. */
1536 if (dflow->out_of_date_transfer_functions)
1538 bitmap_copy (&tmp, dflow->out_of_date_transfer_functions);
1539 bitmap_clear (dflow->out_of_date_transfer_functions);
1540 if (bitmap_bit_p (&tmp, ENTRY_BLOCK))
1541 bitmap_set_bit (dflow->out_of_date_transfer_functions, ENTRY_BLOCK);
1542 if (bitmap_bit_p (&tmp, EXIT_BLOCK))
1543 bitmap_set_bit (dflow->out_of_date_transfer_functions, EXIT_BLOCK);
1545 i = NUM_FIXED_BLOCKS;
1546 FOR_EACH_BB_FN (bb, cfun)
1548 if (bitmap_bit_p (&tmp, bb->index))
1549 bitmap_set_bit (dflow->out_of_date_transfer_functions, i);
1550 i++;
1554 /* Now shuffle the block info for the problem. */
1555 if (dflow->problem->free_bb_fun)
1557 int size = (last_basic_block_for_fn (cfun)
1558 * dflow->problem->block_info_elt_size);
1559 problem_temps = XNEWVAR (char, size);
1560 df_grow_bb_info (dflow);
1561 memcpy (problem_temps, dflow->block_info, size);
1563 /* Copy the bb info from the problem tmps to the proper
1564 place in the block_info vector. Null out the copied
1565 item. The entry and exit blocks never move. */
1566 i = NUM_FIXED_BLOCKS;
1567 FOR_EACH_BB_FN (bb, cfun)
1569 df_set_bb_info (dflow, i,
1570 (char *)problem_temps
1571 + bb->index * dflow->problem->block_info_elt_size);
1572 i++;
1574 memset ((char *)dflow->block_info
1575 + i * dflow->problem->block_info_elt_size, 0,
1576 (last_basic_block_for_fn (cfun) - i)
1577 * dflow->problem->block_info_elt_size);
1578 free (problem_temps);
1582 /* Shuffle the bits in the basic_block indexed arrays. */
1584 if (df->blocks_to_analyze)
1586 if (bitmap_bit_p (&tmp, ENTRY_BLOCK))
1587 bitmap_set_bit (df->blocks_to_analyze, ENTRY_BLOCK);
1588 if (bitmap_bit_p (&tmp, EXIT_BLOCK))
1589 bitmap_set_bit (df->blocks_to_analyze, EXIT_BLOCK);
1590 bitmap_copy (&tmp, df->blocks_to_analyze);
1591 bitmap_clear (df->blocks_to_analyze);
1592 i = NUM_FIXED_BLOCKS;
1593 FOR_EACH_BB_FN (bb, cfun)
1595 if (bitmap_bit_p (&tmp, bb->index))
1596 bitmap_set_bit (df->blocks_to_analyze, i);
1597 i++;
1601 bitmap_clear (&tmp);
1603 i = NUM_FIXED_BLOCKS;
1604 FOR_EACH_BB_FN (bb, cfun)
1606 SET_BASIC_BLOCK_FOR_FN (cfun, i, bb);
1607 bb->index = i;
1608 i++;
1611 gcc_assert (i == n_basic_blocks_for_fn (cfun));
1613 for (; i < last_basic_block_for_fn (cfun); i++)
1614 SET_BASIC_BLOCK_FOR_FN (cfun, i, NULL);
1616 #ifdef DF_DEBUG_CFG
1617 if (!df_lr->solutions_dirty)
1618 df_set_clean_cfg ();
1619 #endif
1623 /* Shove NEW_BLOCK in at OLD_INDEX. Called from ifcvt to hack a
1624 block. There is no excuse for people to do this kind of thing. */
1626 void
1627 df_bb_replace (int old_index, basic_block new_block)
1629 int new_block_index = new_block->index;
1630 int p;
1632 if (dump_file)
1633 fprintf (dump_file, "shoving block %d into %d\n", new_block_index, old_index);
1635 gcc_assert (df);
1636 gcc_assert (BASIC_BLOCK_FOR_FN (cfun, old_index) == NULL);
1638 for (p = 0; p < df->num_problems_defined; p++)
1640 struct dataflow *dflow = df->problems_in_order[p];
1641 if (dflow->block_info)
1643 df_grow_bb_info (dflow);
1644 df_set_bb_info (dflow, old_index,
1645 df_get_bb_info (dflow, new_block_index));
1649 df_clear_bb_dirty (new_block);
1650 SET_BASIC_BLOCK_FOR_FN (cfun, old_index, new_block);
1651 new_block->index = old_index;
1652 df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, old_index));
1653 SET_BASIC_BLOCK_FOR_FN (cfun, new_block_index, NULL);
1657 /* Free all of the per basic block dataflow from all of the problems.
1658 This is typically called before a basic block is deleted and the
1659 problem will be reanalyzed. */
1661 void
1662 df_bb_delete (int bb_index)
1664 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
1665 int i;
1667 if (!df)
1668 return;
1670 for (i = 0; i < df->num_problems_defined; i++)
1672 struct dataflow *dflow = df->problems_in_order[i];
1673 if (dflow->problem->free_bb_fun)
1675 void *bb_info = df_get_bb_info (dflow, bb_index);
1676 if (bb_info)
1678 dflow->problem->free_bb_fun (bb, bb_info);
1679 df_clear_bb_info (dflow, bb_index);
1683 df_clear_bb_dirty (bb);
1684 df_mark_solutions_dirty ();
1688 /* Verify that there is a place for everything and everything is in
1689 its place. This is too expensive to run after every pass in the
1690 mainline. However this is an excellent debugging tool if the
1691 dataflow information is not being updated properly. You can just
1692 sprinkle calls in until you find the place that is changing an
1693 underlying structure without calling the proper updating
1694 routine. */
1696 void
1697 df_verify (void)
1699 df_scan_verify ();
1700 #ifdef ENABLE_DF_CHECKING
1701 df_lr_verify_transfer_functions ();
1702 if (df_live)
1703 df_live_verify_transfer_functions ();
1704 #endif
1707 #ifdef DF_DEBUG_CFG
1709 /* Compute an array of ints that describes the cfg. This can be used
1710 to discover places where the cfg is modified by the appropriate
1711 calls have not been made to the keep df informed. The internals of
1712 this are unexciting, the key is that two instances of this can be
1713 compared to see if any changes have been made to the cfg. */
1715 static int *
1716 df_compute_cfg_image (void)
1718 basic_block bb;
1719 int size = 2 + (2 * n_basic_blocks_for_fn (cfun));
1720 int i;
1721 int * map;
1723 FOR_ALL_BB_FN (bb, cfun)
1725 size += EDGE_COUNT (bb->succs);
1728 map = XNEWVEC (int, size);
1729 map[0] = size;
1730 i = 1;
1731 FOR_ALL_BB_FN (bb, cfun)
1733 edge_iterator ei;
1734 edge e;
1736 map[i++] = bb->index;
1737 FOR_EACH_EDGE (e, ei, bb->succs)
1738 map[i++] = e->dest->index;
1739 map[i++] = -1;
1741 map[i] = -1;
1742 return map;
1745 static int *saved_cfg = NULL;
1748 /* This function compares the saved version of the cfg with the
1749 current cfg and aborts if the two are identical. The function
1750 silently returns if the cfg has been marked as dirty or the two are
1751 the same. */
1753 void
1754 df_check_cfg_clean (void)
1756 int *new_map;
1758 if (!df)
1759 return;
1761 if (df_lr->solutions_dirty)
1762 return;
1764 if (saved_cfg == NULL)
1765 return;
1767 new_map = df_compute_cfg_image ();
1768 gcc_assert (memcmp (saved_cfg, new_map, saved_cfg[0] * sizeof (int)) == 0);
1769 free (new_map);
1773 /* This function builds a cfg fingerprint and squirrels it away in
1774 saved_cfg. */
1776 static void
1777 df_set_clean_cfg (void)
1779 free (saved_cfg);
1780 saved_cfg = df_compute_cfg_image ();
1783 #endif /* DF_DEBUG_CFG */
1784 /*----------------------------------------------------------------------------
1785 PUBLIC INTERFACES TO QUERY INFORMATION.
1786 ----------------------------------------------------------------------------*/
1789 /* Return first def of REGNO within BB. */
1791 df_ref
1792 df_bb_regno_first_def_find (basic_block bb, unsigned int regno)
1794 rtx insn;
1795 df_ref *def_rec;
1796 unsigned int uid;
1798 FOR_BB_INSNS (bb, insn)
1800 if (!INSN_P (insn))
1801 continue;
1803 uid = INSN_UID (insn);
1804 for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
1806 df_ref def = *def_rec;
1807 if (DF_REF_REGNO (def) == regno)
1808 return def;
1811 return NULL;
1815 /* Return last def of REGNO within BB. */
1817 df_ref
1818 df_bb_regno_last_def_find (basic_block bb, unsigned int regno)
1820 rtx insn;
1821 df_ref *def_rec;
1822 unsigned int uid;
1824 FOR_BB_INSNS_REVERSE (bb, insn)
1826 if (!INSN_P (insn))
1827 continue;
1829 uid = INSN_UID (insn);
1830 for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
1832 df_ref def = *def_rec;
1833 if (DF_REF_REGNO (def) == regno)
1834 return def;
1838 return NULL;
1841 /* Finds the reference corresponding to the definition of REG in INSN.
1842 DF is the dataflow object. */
1844 df_ref
1845 df_find_def (rtx insn, rtx reg)
1847 unsigned int uid;
1848 df_ref *def_rec;
1850 if (GET_CODE (reg) == SUBREG)
1851 reg = SUBREG_REG (reg);
1852 gcc_assert (REG_P (reg));
1854 uid = INSN_UID (insn);
1855 for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
1857 df_ref def = *def_rec;
1858 if (DF_REF_REGNO (def) == REGNO (reg))
1859 return def;
1862 return NULL;
1866 /* Return true if REG is defined in INSN, zero otherwise. */
1868 bool
1869 df_reg_defined (rtx insn, rtx reg)
1871 return df_find_def (insn, reg) != NULL;
1875 /* Finds the reference corresponding to the use of REG in INSN.
1876 DF is the dataflow object. */
1878 df_ref
1879 df_find_use (rtx insn, rtx reg)
1881 unsigned int uid;
1882 df_ref *use_rec;
1884 if (GET_CODE (reg) == SUBREG)
1885 reg = SUBREG_REG (reg);
1886 gcc_assert (REG_P (reg));
1888 uid = INSN_UID (insn);
1889 for (use_rec = DF_INSN_UID_USES (uid); *use_rec; use_rec++)
1891 df_ref use = *use_rec;
1892 if (DF_REF_REGNO (use) == REGNO (reg))
1893 return use;
1895 if (df->changeable_flags & DF_EQ_NOTES)
1896 for (use_rec = DF_INSN_UID_EQ_USES (uid); *use_rec; use_rec++)
1898 df_ref use = *use_rec;
1899 if (DF_REF_REGNO (use) == REGNO (reg))
1900 return use;
1902 return NULL;
1906 /* Return true if REG is referenced in INSN, zero otherwise. */
1908 bool
1909 df_reg_used (rtx insn, rtx reg)
1911 return df_find_use (insn, reg) != NULL;
1915 /*----------------------------------------------------------------------------
1916 Debugging and printing functions.
1917 ----------------------------------------------------------------------------*/
1919 /* Write information about registers and basic blocks into FILE.
1920 This is part of making a debugging dump. */
1922 void
1923 dump_regset (regset r, FILE *outf)
1925 unsigned i;
1926 reg_set_iterator rsi;
1928 if (r == NULL)
1930 fputs (" (nil)", outf);
1931 return;
1934 EXECUTE_IF_SET_IN_REG_SET (r, 0, i, rsi)
1936 fprintf (outf, " %d", i);
1937 if (i < FIRST_PSEUDO_REGISTER)
1938 fprintf (outf, " [%s]",
1939 reg_names[i]);
1943 /* Print a human-readable representation of R on the standard error
1944 stream. This function is designed to be used from within the
1945 debugger. */
1946 extern void debug_regset (regset);
1947 DEBUG_FUNCTION void
1948 debug_regset (regset r)
1950 dump_regset (r, stderr);
1951 putc ('\n', stderr);
1954 /* Write information about registers and basic blocks into FILE.
1955 This is part of making a debugging dump. */
1957 void
1958 df_print_regset (FILE *file, bitmap r)
1960 unsigned int i;
1961 bitmap_iterator bi;
1963 if (r == NULL)
1964 fputs (" (nil)", file);
1965 else
1967 EXECUTE_IF_SET_IN_BITMAP (r, 0, i, bi)
1969 fprintf (file, " %d", i);
1970 if (i < FIRST_PSEUDO_REGISTER)
1971 fprintf (file, " [%s]", reg_names[i]);
1974 fprintf (file, "\n");
1978 /* Write information about registers and basic blocks into FILE. The
1979 bitmap is in the form used by df_byte_lr. This is part of making a
1980 debugging dump. */
1982 void
1983 df_print_word_regset (FILE *file, bitmap r)
1985 unsigned int max_reg = max_reg_num ();
1987 if (r == NULL)
1988 fputs (" (nil)", file);
1989 else
1991 unsigned int i;
1992 for (i = FIRST_PSEUDO_REGISTER; i < max_reg; i++)
1994 bool found = (bitmap_bit_p (r, 2 * i)
1995 || bitmap_bit_p (r, 2 * i + 1));
1996 if (found)
1998 int word;
1999 const char * sep = "";
2000 fprintf (file, " %d", i);
2001 fprintf (file, "(");
2002 for (word = 0; word < 2; word++)
2003 if (bitmap_bit_p (r, 2 * i + word))
2005 fprintf (file, "%s%d", sep, word);
2006 sep = ", ";
2008 fprintf (file, ")");
2012 fprintf (file, "\n");
2016 /* Dump dataflow info. */
2018 void
2019 df_dump (FILE *file)
2021 basic_block bb;
2022 df_dump_start (file);
2024 FOR_ALL_BB_FN (bb, cfun)
2026 df_print_bb_index (bb, file);
2027 df_dump_top (bb, file);
2028 df_dump_bottom (bb, file);
2031 fprintf (file, "\n");
2035 /* Dump dataflow info for df->blocks_to_analyze. */
2037 void
2038 df_dump_region (FILE *file)
2040 if (df->blocks_to_analyze)
2042 bitmap_iterator bi;
2043 unsigned int bb_index;
2045 fprintf (file, "\n\nstarting region dump\n");
2046 df_dump_start (file);
2048 EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, bb_index, bi)
2050 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
2051 dump_bb (file, bb, 0, TDF_DETAILS);
2053 fprintf (file, "\n");
2055 else
2056 df_dump (file);
2060 /* Dump the introductory information for each problem defined. */
2062 void
2063 df_dump_start (FILE *file)
2065 int i;
2067 if (!df || !file)
2068 return;
2070 fprintf (file, "\n\n%s\n", current_function_name ());
2071 fprintf (file, "\nDataflow summary:\n");
2072 if (df->blocks_to_analyze)
2073 fprintf (file, "def_info->table_size = %d, use_info->table_size = %d\n",
2074 DF_DEFS_TABLE_SIZE (), DF_USES_TABLE_SIZE ());
2076 for (i = 0; i < df->num_problems_defined; i++)
2078 struct dataflow *dflow = df->problems_in_order[i];
2079 if (dflow->computed)
2081 df_dump_problem_function fun = dflow->problem->dump_start_fun;
2082 if (fun)
2083 fun (file);
2089 /* Dump the top or bottom of the block information for BB. */
2090 static void
2091 df_dump_bb_problem_data (basic_block bb, FILE *file, bool top)
2093 int i;
2095 if (!df || !file)
2096 return;
2098 for (i = 0; i < df->num_problems_defined; i++)
2100 struct dataflow *dflow = df->problems_in_order[i];
2101 if (dflow->computed)
2103 df_dump_bb_problem_function bbfun;
2105 if (top)
2106 bbfun = dflow->problem->dump_top_fun;
2107 else
2108 bbfun = dflow->problem->dump_bottom_fun;
2110 if (bbfun)
2111 bbfun (bb, file);
2116 /* Dump the top of the block information for BB. */
2118 void
2119 df_dump_top (basic_block bb, FILE *file)
2121 df_dump_bb_problem_data (bb, file, /*top=*/true);
2124 /* Dump the bottom of the block information for BB. */
2126 void
2127 df_dump_bottom (basic_block bb, FILE *file)
2129 df_dump_bb_problem_data (bb, file, /*top=*/false);
2133 /* Dump information about INSN just before or after dumping INSN itself. */
2134 static void
2135 df_dump_insn_problem_data (const_rtx insn, FILE *file, bool top)
2137 int i;
2139 if (!df || !file)
2140 return;
2142 for (i = 0; i < df->num_problems_defined; i++)
2144 struct dataflow *dflow = df->problems_in_order[i];
2145 if (dflow->computed)
2147 df_dump_insn_problem_function insnfun;
2149 if (top)
2150 insnfun = dflow->problem->dump_insn_top_fun;
2151 else
2152 insnfun = dflow->problem->dump_insn_bottom_fun;
2154 if (insnfun)
2155 insnfun (insn, file);
2160 /* Dump information about INSN before dumping INSN itself. */
2162 void
2163 df_dump_insn_top (const_rtx insn, FILE *file)
2165 df_dump_insn_problem_data (insn, file, /*top=*/true);
2168 /* Dump information about INSN after dumping INSN itself. */
2170 void
2171 df_dump_insn_bottom (const_rtx insn, FILE *file)
2173 df_dump_insn_problem_data (insn, file, /*top=*/false);
2177 static void
2178 df_ref_dump (df_ref ref, FILE *file)
2180 fprintf (file, "%c%d(%d)",
2181 DF_REF_REG_DEF_P (ref)
2182 ? 'd'
2183 : (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE) ? 'e' : 'u',
2184 DF_REF_ID (ref),
2185 DF_REF_REGNO (ref));
2188 void
2189 df_refs_chain_dump (df_ref *ref_rec, bool follow_chain, FILE *file)
2191 fprintf (file, "{ ");
2192 while (*ref_rec)
2194 df_ref ref = *ref_rec;
2195 df_ref_dump (ref, file);
2196 if (follow_chain)
2197 df_chain_dump (DF_REF_CHAIN (ref), file);
2198 ref_rec++;
2200 fprintf (file, "}");
2204 /* Dump either a ref-def or reg-use chain. */
2206 void
2207 df_regs_chain_dump (df_ref ref, FILE *file)
2209 fprintf (file, "{ ");
2210 while (ref)
2212 df_ref_dump (ref, file);
2213 ref = DF_REF_NEXT_REG (ref);
2215 fprintf (file, "}");
2219 static void
2220 df_mws_dump (struct df_mw_hardreg **mws, FILE *file)
2222 while (*mws)
2224 fprintf (file, "mw %c r[%d..%d]\n",
2225 (DF_MWS_REG_DEF_P (*mws)) ? 'd' : 'u',
2226 (*mws)->start_regno, (*mws)->end_regno);
2227 mws++;
2232 static void
2233 df_insn_uid_debug (unsigned int uid,
2234 bool follow_chain, FILE *file)
2236 fprintf (file, "insn %d luid %d",
2237 uid, DF_INSN_UID_LUID (uid));
2239 if (DF_INSN_UID_DEFS (uid))
2241 fprintf (file, " defs ");
2242 df_refs_chain_dump (DF_INSN_UID_DEFS (uid), follow_chain, file);
2245 if (DF_INSN_UID_USES (uid))
2247 fprintf (file, " uses ");
2248 df_refs_chain_dump (DF_INSN_UID_USES (uid), follow_chain, file);
2251 if (DF_INSN_UID_EQ_USES (uid))
2253 fprintf (file, " eq uses ");
2254 df_refs_chain_dump (DF_INSN_UID_EQ_USES (uid), follow_chain, file);
2257 if (DF_INSN_UID_MWS (uid))
2259 fprintf (file, " mws ");
2260 df_mws_dump (DF_INSN_UID_MWS (uid), file);
2262 fprintf (file, "\n");
2266 DEBUG_FUNCTION void
2267 df_insn_debug (rtx insn, bool follow_chain, FILE *file)
2269 df_insn_uid_debug (INSN_UID (insn), follow_chain, file);
2272 DEBUG_FUNCTION void
2273 df_insn_debug_regno (rtx insn, FILE *file)
2275 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
2277 fprintf (file, "insn %d bb %d luid %d defs ",
2278 INSN_UID (insn), BLOCK_FOR_INSN (insn)->index,
2279 DF_INSN_INFO_LUID (insn_info));
2280 df_refs_chain_dump (DF_INSN_INFO_DEFS (insn_info), false, file);
2282 fprintf (file, " uses ");
2283 df_refs_chain_dump (DF_INSN_INFO_USES (insn_info), false, file);
2285 fprintf (file, " eq_uses ");
2286 df_refs_chain_dump (DF_INSN_INFO_EQ_USES (insn_info), false, file);
2287 fprintf (file, "\n");
2290 DEBUG_FUNCTION void
2291 df_regno_debug (unsigned int regno, FILE *file)
2293 fprintf (file, "reg %d defs ", regno);
2294 df_regs_chain_dump (DF_REG_DEF_CHAIN (regno), file);
2295 fprintf (file, " uses ");
2296 df_regs_chain_dump (DF_REG_USE_CHAIN (regno), file);
2297 fprintf (file, " eq_uses ");
2298 df_regs_chain_dump (DF_REG_EQ_USE_CHAIN (regno), file);
2299 fprintf (file, "\n");
2303 DEBUG_FUNCTION void
2304 df_ref_debug (df_ref ref, FILE *file)
2306 fprintf (file, "%c%d ",
2307 DF_REF_REG_DEF_P (ref) ? 'd' : 'u',
2308 DF_REF_ID (ref));
2309 fprintf (file, "reg %d bb %d insn %d flag %#x type %#x ",
2310 DF_REF_REGNO (ref),
2311 DF_REF_BBNO (ref),
2312 DF_REF_IS_ARTIFICIAL (ref) ? -1 : DF_REF_INSN_UID (ref),
2313 DF_REF_FLAGS (ref),
2314 DF_REF_TYPE (ref));
2315 if (DF_REF_LOC (ref))
2317 if (flag_dump_noaddr)
2318 fprintf (file, "loc #(#) chain ");
2319 else
2320 fprintf (file, "loc %p(%p) chain ", (void *)DF_REF_LOC (ref),
2321 (void *)*DF_REF_LOC (ref));
2323 else
2324 fprintf (file, "chain ");
2325 df_chain_dump (DF_REF_CHAIN (ref), file);
2326 fprintf (file, "\n");
2329 /* Functions for debugging from GDB. */
2331 DEBUG_FUNCTION void
2332 debug_df_insn (rtx insn)
2334 df_insn_debug (insn, true, stderr);
2335 debug_rtx (insn);
2339 DEBUG_FUNCTION void
2340 debug_df_reg (rtx reg)
2342 df_regno_debug (REGNO (reg), stderr);
2346 DEBUG_FUNCTION void
2347 debug_df_regno (unsigned int regno)
2349 df_regno_debug (regno, stderr);
2353 DEBUG_FUNCTION void
2354 debug_df_ref (df_ref ref)
2356 df_ref_debug (ref, stderr);
2360 DEBUG_FUNCTION void
2361 debug_df_defno (unsigned int defno)
2363 df_ref_debug (DF_DEFS_GET (defno), stderr);
2367 DEBUG_FUNCTION void
2368 debug_df_useno (unsigned int defno)
2370 df_ref_debug (DF_USES_GET (defno), stderr);
2374 DEBUG_FUNCTION void
2375 debug_df_chain (struct df_link *link)
2377 df_chain_dump (link, stderr);
2378 fputc ('\n', stderr);