|
0
|
1 /* Allocation for dataflow support routines.
|
|
|
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
|
|
|
3 2008 Free Software Foundation, Inc.
|
|
|
4 Originally contributed by Michael P. Hayes
|
|
|
5 (m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
|
|
|
6 Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
|
|
|
7 and Kenneth Zadeck (zadeck@naturalbridge.com).
|
|
|
8
|
|
|
9 This file is part of GCC.
|
|
|
10
|
|
|
11 GCC is free software; you can redistribute it and/or modify it under
|
|
|
12 the terms of the GNU General Public License as published by the Free
|
|
|
13 Software Foundation; either version 3, or (at your option) any later
|
|
|
14 version.
|
|
|
15
|
|
|
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
19 for more details.
|
|
|
20
|
|
|
21 You should have received a copy of the GNU General Public License
|
|
|
22 along with GCC; see the file COPYING3. If not see
|
|
|
23 <http://www.gnu.org/licenses/>. */
|
|
|
24
|
|
|
25 /*
|
|
|
26 OVERVIEW:
|
|
|
27
|
|
|
28 The files in this collection (df*.c,df.h) provide a general framework
|
|
|
29 for solving dataflow problems. The global dataflow is performed using
|
|
|
30 a good implementation of iterative dataflow analysis.
|
|
|
31
|
|
|
32 The file df-problems.c provides problem instance for the most common
|
|
|
33 dataflow problems: reaching defs, upward exposed uses, live variables,
|
|
|
34 uninitialized variables, def-use chains, and use-def chains. However,
|
|
|
35 the interface allows other dataflow problems to be defined as well.
|
|
|
36
|
|
|
37 Dataflow analysis is available in most of the rtl backend (the parts
|
|
|
38 between pass_df_initialize and pass_df_finish). It is quite likely
|
|
|
39 that these boundaries will be expanded in the future. The only
|
|
|
40 requirement is that there be a correct control flow graph.
|
|
|
41
|
|
|
42 There are three variations of the live variable problem that are
|
|
|
43 available whenever dataflow is available. The LR problem finds the
|
|
|
44 areas that can reach a use of a variable, the UR problems finds the
|
|
|
45 areas that can be reached from a definition of a variable. The LIVE
|
|
|
46 problem finds the intersection of these two areas.
|
|
|
47
|
|
|
48 There are several optional problems. These can be enabled when they
|
|
|
49 are needed and disabled when they are not needed.
|
|
|
50
|
|
|
51 Dataflow problems are generally solved in three layers. The bottom
|
|
|
52 layer is called scanning where a data structure is built for each rtl
|
|
|
53 insn that describes the set of defs and uses of that insn. Scanning
|
|
|
54 is generally kept up to date, i.e. as the insns changes, the scanned
|
|
|
55 version of that insn changes also. There are various mechanisms for
|
|
|
56 making this happen and are described in the INCREMENTAL SCANNING
|
|
|
57 section.
|
|
|
58
|
|
|
59 In the middle layer, basic blocks are scanned to produce transfer
|
|
|
60 functions which describe the effects of that block on the global
|
|
|
61 dataflow solution. The transfer functions are only rebuilt if the
|
|
|
62 some instruction within the block has changed.
|
|
|
63
|
|
|
64 The top layer is the dataflow solution itself. The dataflow solution
|
|
|
65 is computed by using an efficient iterative solver and the transfer
|
|
|
66 functions. The dataflow solution must be recomputed whenever the
|
|
|
67 control changes or if one of the transfer function changes.
|
|
|
68
|
|
|
69
|
|
|
70 USAGE:
|
|
|
71
|
|
|
72 Here is an example of using the dataflow routines.
|
|
|
73
|
|
|
74 df_[chain,live,note,rd]_add_problem (flags);
|
|
|
75
|
|
|
76 df_set_blocks (blocks);
|
|
|
77
|
|
|
78 df_analyze ();
|
|
|
79
|
|
|
80 df_dump (stderr);
|
|
|
81
|
|
|
82 df_finish_pass (false);
|
|
|
83
|
|
|
84 DF_[chain,live,note,rd]_ADD_PROBLEM adds a problem, defined by an
|
|
|
85 instance to struct df_problem, to the set of problems solved in this
|
|
|
86 instance of df. All calls to add a problem for a given instance of df
|
|
|
87 must occur before the first call to DF_ANALYZE.
|
|
|
88
|
|
|
89 Problems can be dependent on other problems. For instance, solving
|
|
|
90 def-use or use-def chains is dependent on solving reaching
|
|
|
91 definitions. As long as these dependencies are listed in the problem
|
|
|
92 definition, the order of adding the problems is not material.
|
|
|
93 Otherwise, the problems will be solved in the order of calls to
|
|
|
94 df_add_problem. Note that it is not necessary to have a problem. In
|
|
|
95 that case, df will just be used to do the scanning.
|
|
|
96
|
|
|
97
|
|
|
98
|
|
|
99 DF_SET_BLOCKS is an optional call used to define a region of the
|
|
|
100 function on which the analysis will be performed. The normal case is
|
|
|
101 to analyze the entire function and no call to df_set_blocks is made.
|
|
|
102 DF_SET_BLOCKS only effects the blocks that are effected when computing
|
|
|
103 the transfer functions and final solution. The insn level information
|
|
|
104 is always kept up to date.
|
|
|
105
|
|
|
106 When a subset is given, the analysis behaves as if the function only
|
|
|
107 contains those blocks and any edges that occur directly between the
|
|
|
108 blocks in the set. Care should be taken to call df_set_blocks right
|
|
|
109 before the call to analyze in order to eliminate the possibility that
|
|
|
110 optimizations that reorder blocks invalidate the bitvector.
|
|
|
111
|
|
|
112 DF_ANALYZE causes all of the defined problems to be (re)solved. When
|
|
|
113 DF_ANALYZE is completes, the IN and OUT sets for each basic block
|
|
|
114 contain the computer information. The DF_*_BB_INFO macros can be used
|
|
|
115 to access these bitvectors. All deferred rescannings are down before
|
|
|
116 the transfer functions are recomputed.
|
|
|
117
|
|
|
118 DF_DUMP can then be called to dump the information produce to some
|
|
|
119 file. This calls DF_DUMP_START, to print the information that is not
|
|
|
120 basic block specific, and then calls DF_DUMP_TOP and DF_DUMP_BOTTOM
|
|
|
121 for each block to print the basic specific information. These parts
|
|
|
122 can all be called separately as part of a larger dump function.
|
|
|
123
|
|
|
124
|
|
|
125 DF_FINISH_PASS causes df_remove_problem to be called on all of the
|
|
|
126 optional problems. It also causes any insns whose scanning has been
|
|
|
127 deferred to be rescanned as well as clears all of the changeable flags.
|
|
|
128 Setting the pass manager TODO_df_finish flag causes this function to
|
|
|
129 be run. However, the pass manager will call df_finish_pass AFTER the
|
|
|
130 pass dumping has been done, so if you want to see the results of the
|
|
|
131 optional problems in the pass dumps, use the TODO flag rather than
|
|
|
132 calling the function yourself.
|
|
|
133
|
|
|
134 INCREMENTAL SCANNING
|
|
|
135
|
|
|
136 There are four ways of doing the incremental scanning:
|
|
|
137
|
|
|
138 1) Immediate rescanning - Calls to df_insn_rescan, df_notes_rescan,
|
|
|
139 df_bb_delete, df_insn_change_bb have been added to most of
|
|
|
140 the low level service functions that maintain the cfg and change
|
|
|
141 rtl. Calling and of these routines many cause some number of insns
|
|
|
142 to be rescanned.
|
|
|
143
|
|
|
144 For most modern rtl passes, this is certainly the easiest way to
|
|
|
145 manage rescanning the insns. This technique also has the advantage
|
|
|
146 that the scanning information is always correct and can be relied
|
|
|
147 upon even after changes have been made to the instructions. This
|
|
|
148 technique is contra indicated in several cases:
|
|
|
149
|
|
|
150 a) If def-use chains OR use-def chains (but not both) are built,
|
|
|
151 using this is SIMPLY WRONG. The problem is that when a ref is
|
|
|
152 deleted that is the target of an edge, there is not enough
|
|
|
153 information to efficiently find the source of the edge and
|
|
|
154 delete the edge. This leaves a dangling reference that may
|
|
|
155 cause problems.
|
|
|
156
|
|
|
157 b) If def-use chains AND use-def chains are built, this may
|
|
|
158 produce unexpected results. The problem is that the incremental
|
|
|
159 scanning of an insn does not know how to repair the chains that
|
|
|
160 point into an insn when the insn changes. So the incremental
|
|
|
161 scanning just deletes the chains that enter and exit the insn
|
|
|
162 being changed. The dangling reference issue in (a) is not a
|
|
|
163 problem here, but if the pass is depending on the chains being
|
|
|
164 maintained after insns have been modified, this technique will
|
|
|
165 not do the correct thing.
|
|
|
166
|
|
|
167 c) If the pass modifies insns several times, this incremental
|
|
|
168 updating may be expensive.
|
|
|
169
|
|
|
170 d) If the pass modifies all of the insns, as does register
|
|
|
171 allocation, it is simply better to rescan the entire function.
|
|
|
172
|
|
|
173 e) If the pass uses either non-standard or ancient techniques to
|
|
|
174 modify insns, automatic detection of the insns that need to be
|
|
|
175 rescanned may be impractical. Cse and regrename fall into this
|
|
|
176 category.
|
|
|
177
|
|
|
178 2) Deferred rescanning - Calls to df_insn_rescan, df_notes_rescan, and
|
|
|
179 df_insn_delete do not immediately change the insn but instead make
|
|
|
180 a note that the insn needs to be rescanned. The next call to
|
|
|
181 df_analyze, df_finish_pass, or df_process_deferred_rescans will
|
|
|
182 cause all of the pending rescans to be processed.
|
|
|
183
|
|
|
184 This is the technique of choice if either 1a, 1b, or 1c are issues
|
|
|
185 in the pass. In the case of 1a or 1b, a call to df_remove_problem
|
|
|
186 (df_chain) should be made before the next call to df_analyze or
|
|
|
187 df_process_deferred_rescans.
|
|
|
188
|
|
|
189 To enable this mode, call df_set_flags (DF_DEFER_INSN_RESCAN).
|
|
|
190 (This mode can be cleared by calling df_clear_flags
|
|
|
191 (DF_DEFER_INSN_RESCAN) but this does not cause the deferred insns to
|
|
|
192 be rescanned.
|
|
|
193
|
|
|
194 3) Total rescanning - In this mode the rescanning is disabled.
|
|
|
195 However, the df information associated with deleted insn is delete
|
|
|
196 at the time the insn is deleted. At the end of the pass, a call
|
|
|
197 must be made to df_insn_rescan_all. This method is used by the
|
|
|
198 register allocator since it generally changes each insn multiple
|
|
|
199 times (once for each ref) and does not need to make use of the
|
|
|
200 updated scanning information.
|
|
|
201
|
|
|
202 It is also currently used by two older passes (cse, and regrename)
|
|
|
203 which change insns in hard to track ways. It is hoped that this
|
|
|
204 will be fixed soon since this it is expensive to rescan all of the
|
|
|
205 insns when only a small number of them have really changed.
|
|
|
206
|
|
|
207 4) Do it yourself - In this mechanism, the pass updates the insns
|
|
|
208 itself using the low level df primitives. Currently no pass does
|
|
|
209 this, but it has the advantage that it is quite efficient given
|
|
|
210 that the pass generally has exact knowledge of what it is changing.
|
|
|
211
|
|
|
212 DATA STRUCTURES
|
|
|
213
|
|
|
214 Scanning produces a `struct df_ref' data structure (ref) is allocated
|
|
|
215 for every register reference (def or use) and this records the insn
|
|
|
216 and bb the ref is found within. The refs are linked together in
|
|
|
217 chains of uses and defs for each insn and for each register. Each ref
|
|
|
218 also has a chain field that links all the use refs for a def or all
|
|
|
219 the def refs for a use. This is used to create use-def or def-use
|
|
|
220 chains.
|
|
|
221
|
|
|
222 Different optimizations have different needs. Ultimately, only
|
|
|
223 register allocation and schedulers should be using the bitmaps
|
|
|
224 produced for the live register and uninitialized register problems.
|
|
|
225 The rest of the backend should be upgraded to using and maintaining
|
|
|
226 the linked information such as def use or use def chains.
|
|
|
227
|
|
|
228
|
|
|
229 PHILOSOPHY:
|
|
|
230
|
|
|
231 While incremental bitmaps are not worthwhile to maintain, incremental
|
|
|
232 chains may be perfectly reasonable. The fastest way to build chains
|
|
|
233 from scratch or after significant modifications is to build reaching
|
|
|
234 definitions (RD) and build the chains from this.
|
|
|
235
|
|
|
236 However, general algorithms for maintaining use-def or def-use chains
|
|
|
237 are not practical. The amount of work to recompute the chain any
|
|
|
238 chain after an arbitrary change is large. However, with a modest
|
|
|
239 amount of work it is generally possible to have the application that
|
|
|
240 uses the chains keep them up to date. The high level knowledge of
|
|
|
241 what is really happening is essential to crafting efficient
|
|
|
242 incremental algorithms.
|
|
|
243
|
|
|
244 As for the bit vector problems, there is no interface to give a set of
|
|
|
245 blocks over with to resolve the iteration. In general, restarting a
|
|
|
246 dataflow iteration is difficult and expensive. Again, the best way to
|
|
|
247 keep the dataflow information up to data (if this is really what is
|
|
|
248 needed) it to formulate a problem specific solution.
|
|
|
249
|
|
|
250 There are fine grained calls for creating and deleting references from
|
|
|
251 instructions in df-scan.c. However, these are not currently connected
|
|
|
252 to the engine that resolves the dataflow equations.
|
|
|
253
|
|
|
254
|
|
|
255 DATA STRUCTURES:
|
|
|
256
|
|
|
257 The basic object is a DF_REF (reference) and this may either be a
|
|
|
258 DEF (definition) or a USE of a register.
|
|
|
259
|
|
|
260 These are linked into a variety of lists; namely reg-def, reg-use,
|
|
|
261 insn-def, insn-use, def-use, and use-def lists. For example, the
|
|
|
262 reg-def lists contain all the locations that define a given register
|
|
|
263 while the insn-use lists contain all the locations that use a
|
|
|
264 register.
|
|
|
265
|
|
|
266 Note that the reg-def and reg-use chains are generally short for
|
|
|
267 pseudos and long for the hard registers.
|
|
|
268
|
|
|
269 ACCESSING INSNS:
|
|
|
270
|
|
|
271 1) The df insn information is kept in an array of DF_INSN_INFO objects.
|
|
|
272 The array is indexed by insn uid, and every DF_REF points to the
|
|
|
273 DF_INSN_INFO object of the insn that contains the reference.
|
|
|
274
|
|
|
275 2) Each insn has three sets of refs, which are linked into one of three
|
|
|
276 lists: The insn's defs list (accessed by the DF_INSN_INFO_DEFS,
|
|
|
277 DF_INSN_DEFS, or DF_INSN_UID_DEFS macros), the insn's uses list
|
|
|
278 (accessed by the DF_INSN_INFO_USES, DF_INSN_USES, or
|
|
|
279 DF_INSN_UID_USES macros) or the insn's eq_uses list (accessed by the
|
|
|
280 DF_INSN_INFO_EQ_USES, DF_INSN_EQ_USES or DF_INSN_UID_EQ_USES macros).
|
|
|
281 The latter list are the list of references in REG_EQUAL or REG_EQUIV
|
|
|
282 notes. These macros produce a ref (or NULL), the rest of the list
|
|
|
283 can be obtained by traversal of the NEXT_REF field (accessed by the
|
|
|
284 DF_REF_NEXT_REF macro.) There is no significance to the ordering of
|
|
|
285 the uses or refs in an instruction.
|
|
|
286
|
|
|
287 3) Each insn has a logical uid field (LUID) which is stored in the
|
|
|
288 DF_INSN_INFO object for the insn. The LUID field is accessed by
|
|
|
289 the DF_INSN_INFO_LUID, DF_INSN_LUID, and DF_INSN_UID_LUID macros.
|
|
|
290 When properly set, the LUID is an integer that numbers each insn in
|
|
|
291 the basic block, in order from the start of the block.
|
|
|
292 The numbers are only correct after a call to df_analyze. They will
|
|
|
293 rot after insns are added deleted or moved round.
|
|
|
294
|
|
|
295 ACCESSING REFS:
|
|
|
296
|
|
|
297 There are 4 ways to obtain access to refs:
|
|
|
298
|
|
|
299 1) References are divided into two categories, REAL and ARTIFICIAL.
|
|
|
300
|
|
|
301 REAL refs are associated with instructions.
|
|
|
302
|
|
|
303 ARTIFICIAL refs are associated with basic blocks. The heads of
|
|
|
304 these lists can be accessed by calling df_get_artificial_defs or
|
|
|
305 df_get_artificial_uses for the particular basic block.
|
|
|
306
|
|
|
307 Artificial defs and uses occur both at the beginning and ends of blocks.
|
|
|
308
|
|
|
309 For blocks that area at the destination of eh edges, the
|
|
|
310 artificial uses and defs occur at the beginning. The defs relate
|
|
|
311 to the registers specified in EH_RETURN_DATA_REGNO and the uses
|
|
|
312 relate to the registers specified in ED_USES. Logically these
|
|
|
313 defs and uses should really occur along the eh edge, but there is
|
|
|
314 no convenient way to do this. Artificial edges that occur at the
|
|
|
315 beginning of the block have the DF_REF_AT_TOP flag set.
|
|
|
316
|
|
|
317 Artificial uses occur at the end of all blocks. These arise from
|
|
|
318 the hard registers that are always live, such as the stack
|
|
|
319 register and are put there to keep the code from forgetting about
|
|
|
320 them.
|
|
|
321
|
|
|
322 Artificial defs occur at the end of the entry block. These arise
|
|
|
323 from registers that are live at entry to the function.
|
|
|
324
|
|
|
325 2) There are three types of refs: defs, uses and eq_uses. (Eq_uses are
|
|
|
326 uses that appear inside a REG_EQUAL or REG_EQUIV note.)
|
|
|
327
|
|
|
328 All of the eq_uses, uses and defs associated with each pseudo or
|
|
|
329 hard register may be linked in a bidirectional chain. These are
|
|
|
330 called reg-use or reg_def chains. If the changeable flag
|
|
|
331 DF_EQ_NOTES is set when the chains are built, the eq_uses will be
|
|
|
332 treated like uses. If it is not set they are ignored.
|
|
|
333
|
|
|
334 The first use, eq_use or def for a register can be obtained using
|
|
|
335 the DF_REG_USE_CHAIN, DF_REG_EQ_USE_CHAIN or DF_REG_DEF_CHAIN
|
|
|
336 macros. Subsequent uses for the same regno can be obtained by
|
|
|
337 following the next_reg field of the ref. The number of elements in
|
|
|
338 each of the chains can be found by using the DF_REG_USE_COUNT,
|
|
|
339 DF_REG_EQ_USE_COUNT or DF_REG_DEF_COUNT macros.
|
|
|
340
|
|
|
341 In previous versions of this code, these chains were ordered. It
|
|
|
342 has not been practical to continue this practice.
|
|
|
343
|
|
|
344 3) If def-use or use-def chains are built, these can be traversed to
|
|
|
345 get to other refs. If the flag DF_EQ_NOTES has been set, the chains
|
|
|
346 include the eq_uses. Otherwise these are ignored when building the
|
|
|
347 chains.
|
|
|
348
|
|
|
349 4) An array of all of the uses (and an array of all of the defs) can
|
|
|
350 be built. These arrays are indexed by the value in the id
|
|
|
351 structure. These arrays are only lazily kept up to date, and that
|
|
|
352 process can be expensive. To have these arrays built, call
|
|
|
353 df_reorganize_defs or df_reorganize_uses. If the flag DF_EQ_NOTES
|
|
|
354 has been set the array will contain the eq_uses. Otherwise these
|
|
|
355 are ignored when building the array and assigning the ids. Note
|
|
|
356 that the values in the id field of a ref may change across calls to
|
|
|
357 df_analyze or df_reorganize_defs or df_reorganize_uses.
|
|
|
358
|
|
|
359 If the only use of this array is to find all of the refs, it is
|
|
|
360 better to traverse all of the registers and then traverse all of
|
|
|
361 reg-use or reg-def chains.
|
|
|
362
|
|
|
363 NOTES:
|
|
|
364
|
|
|
365 Embedded addressing side-effects, such as POST_INC or PRE_INC, generate
|
|
|
366 both a use and a def. These are both marked read/write to show that they
|
|
|
367 are dependent. For example, (set (reg 40) (mem (post_inc (reg 42))))
|
|
|
368 will generate a use of reg 42 followed by a def of reg 42 (both marked
|
|
|
369 read/write). Similarly, (set (reg 40) (mem (pre_dec (reg 41))))
|
|
|
370 generates a use of reg 41 then a def of reg 41 (both marked read/write),
|
|
|
371 even though reg 41 is decremented before it is used for the memory
|
|
|
372 address in this second example.
|
|
|
373
|
|
|
374 A set to a REG inside a ZERO_EXTRACT, or a set to a non-paradoxical SUBREG
|
|
|
375 for which the number of word_mode units covered by the outer mode is
|
|
|
376 smaller than that covered by the inner mode, invokes a read-modify-write
|
|
|
377 operation. We generate both a use and a def and again mark them
|
|
|
378 read/write.
|
|
|
379
|
|
|
380 Paradoxical subreg writes do not leave a trace of the old content, so they
|
|
|
381 are write-only operations.
|
|
|
382 */
|
|
|
383
|
|
|
384
|
|
|
385 #include "config.h"
|
|
|
386 #include "system.h"
|
|
|
387 #include "coretypes.h"
|
|
|
388 #include "tm.h"
|
|
|
389 #include "rtl.h"
|
|
|
390 #include "tm_p.h"
|
|
|
391 #include "insn-config.h"
|
|
|
392 #include "recog.h"
|
|
|
393 #include "function.h"
|
|
|
394 #include "regs.h"
|
|
|
395 #include "output.h"
|
|
|
396 #include "alloc-pool.h"
|
|
|
397 #include "flags.h"
|
|
|
398 #include "hard-reg-set.h"
|
|
|
399 #include "basic-block.h"
|
|
|
400 #include "sbitmap.h"
|
|
|
401 #include "bitmap.h"
|
|
|
402 #include "timevar.h"
|
|
|
403 #include "df.h"
|
|
|
404 #include "tree-pass.h"
|
|
|
405 #include "params.h"
|
|
|
406
|
|
|
407 static void *df_get_bb_info (struct dataflow *, unsigned int);
|
|
|
408 static void df_set_bb_info (struct dataflow *, unsigned int, void *);
|
|
|
409 #ifdef DF_DEBUG_CFG
|
|
|
410 static void df_set_clean_cfg (void);
|
|
|
411 #endif
|
|
|
412
|
|
|
413 /* An obstack for bitmap not related to specific dataflow problems.
|
|
|
414 This obstack should e.g. be used for bitmaps with a short life time
|
|
|
415 such as temporary bitmaps. */
|
|
|
416
|
|
|
417 bitmap_obstack df_bitmap_obstack;
|
|
|
418
|
|
|
419
|
|
|
420 /*----------------------------------------------------------------------------
|
|
|
421 Functions to create, destroy and manipulate an instance of df.
|
|
|
422 ----------------------------------------------------------------------------*/
|
|
|
423
|
|
|
424 struct df *df;
|
|
|
425
|
|
|
426 /* Add PROBLEM (and any dependent problems) to the DF instance. */
|
|
|
427
|
|
|
428 void
|
|
|
429 df_add_problem (struct df_problem *problem)
|
|
|
430 {
|
|
|
431 struct dataflow *dflow;
|
|
|
432 int i;
|
|
|
433
|
|
|
434 /* First try to add the dependent problem. */
|
|
|
435 if (problem->dependent_problem)
|
|
|
436 df_add_problem (problem->dependent_problem);
|
|
|
437
|
|
|
438 /* Check to see if this problem has already been defined. If it
|
|
|
439 has, just return that instance, if not, add it to the end of the
|
|
|
440 vector. */
|
|
|
441 dflow = df->problems_by_index[problem->id];
|
|
|
442 if (dflow)
|
|
|
443 return;
|
|
|
444
|
|
|
445 /* Make a new one and add it to the end. */
|
|
|
446 dflow = XCNEW (struct dataflow);
|
|
|
447 dflow->problem = problem;
|
|
|
448 dflow->computed = false;
|
|
|
449 dflow->solutions_dirty = true;
|
|
|
450 df->problems_by_index[dflow->problem->id] = dflow;
|
|
|
451
|
|
|
452 /* Keep the defined problems ordered by index. This solves the
|
|
|
453 problem that RI will use the information from UREC if UREC has
|
|
|
454 been defined, or from LIVE if LIVE is defined and otherwise LR.
|
|
|
455 However for this to work, the computation of RI must be pushed
|
|
|
456 after which ever of those problems is defined, but we do not
|
|
|
457 require any of those except for LR to have actually been
|
|
|
458 defined. */
|
|
|
459 df->num_problems_defined++;
|
|
|
460 for (i = df->num_problems_defined - 2; i >= 0; i--)
|
|
|
461 {
|
|
|
462 if (problem->id < df->problems_in_order[i]->problem->id)
|
|
|
463 df->problems_in_order[i+1] = df->problems_in_order[i];
|
|
|
464 else
|
|
|
465 {
|
|
|
466 df->problems_in_order[i+1] = dflow;
|
|
|
467 return;
|
|
|
468 }
|
|
|
469 }
|
|
|
470 df->problems_in_order[0] = dflow;
|
|
|
471 }
|
|
|
472
|
|
|
473
|
|
|
474 /* Set the MASK flags in the DFLOW problem. The old flags are
|
|
|
475 returned. If a flag is not allowed to be changed this will fail if
|
|
|
476 checking is enabled. */
|
|
|
477 enum df_changeable_flags
|
|
|
478 df_set_flags (enum df_changeable_flags changeable_flags)
|
|
|
479 {
|
|
|
480 enum df_changeable_flags old_flags = df->changeable_flags;
|
|
|
481 df->changeable_flags |= changeable_flags;
|
|
|
482 return old_flags;
|
|
|
483 }
|
|
|
484
|
|
|
485
|
|
|
486 /* Clear the MASK flags in the DFLOW problem. The old flags are
|
|
|
487 returned. If a flag is not allowed to be changed this will fail if
|
|
|
488 checking is enabled. */
|
|
|
489 enum df_changeable_flags
|
|
|
490 df_clear_flags (enum df_changeable_flags changeable_flags)
|
|
|
491 {
|
|
|
492 enum df_changeable_flags old_flags = df->changeable_flags;
|
|
|
493 df->changeable_flags &= ~changeable_flags;
|
|
|
494 return old_flags;
|
|
|
495 }
|
|
|
496
|
|
|
497
|
|
|
498 /* Set the blocks that are to be considered for analysis. If this is
|
|
|
499 not called or is called with null, the entire function in
|
|
|
500 analyzed. */
|
|
|
501
|
|
|
502 void
|
|
|
503 df_set_blocks (bitmap blocks)
|
|
|
504 {
|
|
|
505 if (blocks)
|
|
|
506 {
|
|
|
507 if (dump_file)
|
|
|
508 bitmap_print (dump_file, blocks, "setting blocks to analyze ", "\n");
|
|
|
509 if (df->blocks_to_analyze)
|
|
|
510 {
|
|
|
511 /* This block is called to change the focus from one subset
|
|
|
512 to another. */
|
|
|
513 int p;
|
|
|
514 bitmap diff = BITMAP_ALLOC (&df_bitmap_obstack);
|
|
|
515 bitmap_and_compl (diff, df->blocks_to_analyze, blocks);
|
|
|
516 for (p = 0; p < df->num_problems_defined; p++)
|
|
|
517 {
|
|
|
518 struct dataflow *dflow = df->problems_in_order[p];
|
|
|
519 if (dflow->optional_p && dflow->problem->reset_fun)
|
|
|
520 dflow->problem->reset_fun (df->blocks_to_analyze);
|
|
|
521 else if (dflow->problem->free_blocks_on_set_blocks)
|
|
|
522 {
|
|
|
523 bitmap_iterator bi;
|
|
|
524 unsigned int bb_index;
|
|
|
525
|
|
|
526 EXECUTE_IF_SET_IN_BITMAP (diff, 0, bb_index, bi)
|
|
|
527 {
|
|
|
528 basic_block bb = BASIC_BLOCK (bb_index);
|
|
|
529 if (bb)
|
|
|
530 {
|
|
|
531 void *bb_info = df_get_bb_info (dflow, bb_index);
|
|
|
532 if (bb_info)
|
|
|
533 {
|
|
|
534 dflow->problem->free_bb_fun (bb, bb_info);
|
|
|
535 df_set_bb_info (dflow, bb_index, NULL);
|
|
|
536 }
|
|
|
537 }
|
|
|
538 }
|
|
|
539 }
|
|
|
540 }
|
|
|
541
|
|
|
542 BITMAP_FREE (diff);
|
|
|
543 }
|
|
|
544 else
|
|
|
545 {
|
|
|
546 /* This block of code is executed to change the focus from
|
|
|
547 the entire function to a subset. */
|
|
|
548 bitmap blocks_to_reset = NULL;
|
|
|
549 int p;
|
|
|
550 for (p = 0; p < df->num_problems_defined; p++)
|
|
|
551 {
|
|
|
552 struct dataflow *dflow = df->problems_in_order[p];
|
|
|
553 if (dflow->optional_p && dflow->problem->reset_fun)
|
|
|
554 {
|
|
|
555 if (!blocks_to_reset)
|
|
|
556 {
|
|
|
557 basic_block bb;
|
|
|
558 blocks_to_reset =
|
|
|
559 BITMAP_ALLOC (&df_bitmap_obstack);
|
|
|
560 FOR_ALL_BB(bb)
|
|
|
561 {
|
|
|
562 bitmap_set_bit (blocks_to_reset, bb->index);
|
|
|
563 }
|
|
|
564 }
|
|
|
565 dflow->problem->reset_fun (blocks_to_reset);
|
|
|
566 }
|
|
|
567 }
|
|
|
568 if (blocks_to_reset)
|
|
|
569 BITMAP_FREE (blocks_to_reset);
|
|
|
570
|
|
|
571 df->blocks_to_analyze = BITMAP_ALLOC (&df_bitmap_obstack);
|
|
|
572 }
|
|
|
573 bitmap_copy (df->blocks_to_analyze, blocks);
|
|
|
574 df->analyze_subset = true;
|
|
|
575 }
|
|
|
576 else
|
|
|
577 {
|
|
|
578 /* This block is executed to reset the focus to the entire
|
|
|
579 function. */
|
|
|
580 if (dump_file)
|
|
|
581 fprintf (dump_file, "clearing blocks_to_analyze\n");
|
|
|
582 if (df->blocks_to_analyze)
|
|
|
583 {
|
|
|
584 BITMAP_FREE (df->blocks_to_analyze);
|
|
|
585 df->blocks_to_analyze = NULL;
|
|
|
586 }
|
|
|
587 df->analyze_subset = false;
|
|
|
588 }
|
|
|
589
|
|
|
590 /* Setting the blocks causes the refs to be unorganized since only
|
|
|
591 the refs in the blocks are seen. */
|
|
|
592 df_maybe_reorganize_def_refs (DF_REF_ORDER_NO_TABLE);
|
|
|
593 df_maybe_reorganize_use_refs (DF_REF_ORDER_NO_TABLE);
|
|
|
594 df_mark_solutions_dirty ();
|
|
|
595 }
|
|
|
596
|
|
|
597
|
|
|
598 /* Delete a DFLOW problem (and any problems that depend on this
|
|
|
599 problem). */
|
|
|
600
|
|
|
601 void
|
|
|
602 df_remove_problem (struct dataflow *dflow)
|
|
|
603 {
|
|
|
604 struct df_problem *problem;
|
|
|
605 int i;
|
|
|
606
|
|
|
607 if (!dflow)
|
|
|
608 return;
|
|
|
609
|
|
|
610 problem = dflow->problem;
|
|
|
611 gcc_assert (problem->remove_problem_fun);
|
|
|
612
|
|
|
613 /* Delete any problems that depended on this problem first. */
|
|
|
614 for (i = 0; i < df->num_problems_defined; i++)
|
|
|
615 if (df->problems_in_order[i]->problem->dependent_problem == problem)
|
|
|
616 df_remove_problem (df->problems_in_order[i]);
|
|
|
617
|
|
|
618 /* Now remove this problem. */
|
|
|
619 for (i = 0; i < df->num_problems_defined; i++)
|
|
|
620 if (df->problems_in_order[i] == dflow)
|
|
|
621 {
|
|
|
622 int j;
|
|
|
623 for (j = i + 1; j < df->num_problems_defined; j++)
|
|
|
624 df->problems_in_order[j-1] = df->problems_in_order[j];
|
|
|
625 df->problems_in_order[j-1] = NULL;
|
|
|
626 df->num_problems_defined--;
|
|
|
627 break;
|
|
|
628 }
|
|
|
629
|
|
|
630 (problem->remove_problem_fun) ();
|
|
|
631 df->problems_by_index[problem->id] = NULL;
|
|
|
632 }
|
|
|
633
|
|
|
634
|
|
|
635 /* Remove all of the problems that are not permanent. Scanning, LR
|
|
|
636 and (at -O2 or higher) LIVE are permanent, the rest are removable.
|
|
|
637 Also clear all of the changeable_flags. */
|
|
|
638
|
|
|
639 void
|
|
|
640 df_finish_pass (bool verify ATTRIBUTE_UNUSED)
|
|
|
641 {
|
|
|
642 int i;
|
|
|
643 int removed = 0;
|
|
|
644
|
|
|
645 #ifdef ENABLE_DF_CHECKING
|
|
|
646 enum df_changeable_flags saved_flags;
|
|
|
647 #endif
|
|
|
648
|
|
|
649 if (!df)
|
|
|
650 return;
|
|
|
651
|
|
|
652 df_maybe_reorganize_def_refs (DF_REF_ORDER_NO_TABLE);
|
|
|
653 df_maybe_reorganize_use_refs (DF_REF_ORDER_NO_TABLE);
|
|
|
654
|
|
|
655 #ifdef ENABLE_DF_CHECKING
|
|
|
656 saved_flags = df->changeable_flags;
|
|
|
657 #endif
|
|
|
658
|
|
|
659 for (i = 0; i < df->num_problems_defined; i++)
|
|
|
660 {
|
|
|
661 struct dataflow *dflow = df->problems_in_order[i];
|
|
|
662 struct df_problem *problem = dflow->problem;
|
|
|
663
|
|
|
664 if (dflow->optional_p)
|
|
|
665 {
|
|
|
666 gcc_assert (problem->remove_problem_fun);
|
|
|
667 (problem->remove_problem_fun) ();
|
|
|
668 df->problems_in_order[i] = NULL;
|
|
|
669 df->problems_by_index[problem->id] = NULL;
|
|
|
670 removed++;
|
|
|
671 }
|
|
|
672 }
|
|
|
673 df->num_problems_defined -= removed;
|
|
|
674
|
|
|
675 /* Clear all of the flags. */
|
|
|
676 df->changeable_flags = 0;
|
|
|
677 df_process_deferred_rescans ();
|
|
|
678
|
|
|
679 /* Set the focus back to the whole function. */
|
|
|
680 if (df->blocks_to_analyze)
|
|
|
681 {
|
|
|
682 BITMAP_FREE (df->blocks_to_analyze);
|
|
|
683 df->blocks_to_analyze = NULL;
|
|
|
684 df_mark_solutions_dirty ();
|
|
|
685 df->analyze_subset = false;
|
|
|
686 }
|
|
|
687
|
|
|
688 #ifdef ENABLE_DF_CHECKING
|
|
|
689 /* Verification will fail in DF_NO_INSN_RESCAN. */
|
|
|
690 if (!(saved_flags & DF_NO_INSN_RESCAN))
|
|
|
691 {
|
|
|
692 df_lr_verify_transfer_functions ();
|
|
|
693 if (df_live)
|
|
|
694 df_live_verify_transfer_functions ();
|
|
|
695 }
|
|
|
696
|
|
|
697 #ifdef DF_DEBUG_CFG
|
|
|
698 df_set_clean_cfg ();
|
|
|
699 #endif
|
|
|
700 #endif
|
|
|
701
|
|
|
702 #ifdef ENABLE_CHECKING
|
|
|
703 if (verify)
|
|
|
704 df->changeable_flags |= DF_VERIFY_SCHEDULED;
|
|
|
705 #endif
|
|
|
706 }
|
|
|
707
|
|
|
708
|
|
|
709 /* Set up the dataflow instance for the entire back end. */
|
|
|
710
|
|
|
711 static unsigned int
|
|
|
712 rest_of_handle_df_initialize (void)
|
|
|
713 {
|
|
|
714 gcc_assert (!df);
|
|
|
715 df = XCNEW (struct df);
|
|
|
716 df->changeable_flags = 0;
|
|
|
717
|
|
|
718 bitmap_obstack_initialize (&df_bitmap_obstack);
|
|
|
719
|
|
|
720 /* Set this to a conservative value. Stack_ptr_mod will compute it
|
|
|
721 correctly later. */
|
|
|
722 current_function_sp_is_unchanging = 0;
|
|
|
723
|
|
|
724 df_scan_add_problem ();
|
|
|
725 df_scan_alloc (NULL);
|
|
|
726
|
|
|
727 /* These three problems are permanent. */
|
|
|
728 df_lr_add_problem ();
|
|
|
729 if (optimize > 1)
|
|
|
730 df_live_add_problem ();
|
|
|
731
|
|
|
732 df->postorder = XNEWVEC (int, last_basic_block);
|
|
|
733 df->postorder_inverted = XNEWVEC (int, last_basic_block);
|
|
|
734 df->n_blocks = post_order_compute (df->postorder, true, true);
|
|
|
735 df->n_blocks_inverted = inverted_post_order_compute (df->postorder_inverted);
|
|
|
736 gcc_assert (df->n_blocks == df->n_blocks_inverted);
|
|
|
737
|
|
|
738 df->hard_regs_live_count = XNEWVEC (unsigned int, FIRST_PSEUDO_REGISTER);
|
|
|
739 memset (df->hard_regs_live_count, 0,
|
|
|
740 sizeof (unsigned int) * FIRST_PSEUDO_REGISTER);
|
|
|
741
|
|
|
742 df_hard_reg_init ();
|
|
|
743 /* After reload, some ports add certain bits to regs_ever_live so
|
|
|
744 this cannot be reset. */
|
|
|
745 df_compute_regs_ever_live (true);
|
|
|
746 df_scan_blocks ();
|
|
|
747 df_compute_regs_ever_live (false);
|
|
|
748 return 0;
|
|
|
749 }
|
|
|
750
|
|
|
751
|
|
|
752 static bool
|
|
|
753 gate_opt (void)
|
|
|
754 {
|
|
|
755 return optimize > 0;
|
|
|
756 }
|
|
|
757
|
|
|
758
|
|
|
759 struct rtl_opt_pass pass_df_initialize_opt =
|
|
|
760 {
|
|
|
761 {
|
|
|
762 RTL_PASS,
|
|
|
763 "dfinit", /* name */
|
|
|
764 gate_opt, /* gate */
|
|
|
765 rest_of_handle_df_initialize, /* execute */
|
|
|
766 NULL, /* sub */
|
|
|
767 NULL, /* next */
|
|
|
768 0, /* static_pass_number */
|
|
|
769 0, /* tv_id */
|
|
|
770 0, /* properties_required */
|
|
|
771 0, /* properties_provided */
|
|
|
772 0, /* properties_destroyed */
|
|
|
773 0, /* todo_flags_start */
|
|
|
774 0 /* todo_flags_finish */
|
|
|
775 }
|
|
|
776 };
|
|
|
777
|
|
|
778
|
|
|
779 static bool
|
|
|
780 gate_no_opt (void)
|
|
|
781 {
|
|
|
782 return optimize == 0;
|
|
|
783 }
|
|
|
784
|
|
|
785
|
|
|
786 struct rtl_opt_pass pass_df_initialize_no_opt =
|
|
|
787 {
|
|
|
788 {
|
|
|
789 RTL_PASS,
|
|
|
790 "dfinit", /* name */
|
|
|
791 gate_no_opt, /* gate */
|
|
|
792 rest_of_handle_df_initialize, /* execute */
|
|
|
793 NULL, /* sub */
|
|
|
794 NULL, /* next */
|
|
|
795 0, /* static_pass_number */
|
|
|
796 0, /* tv_id */
|
|
|
797 0, /* properties_required */
|
|
|
798 0, /* properties_provided */
|
|
|
799 0, /* properties_destroyed */
|
|
|
800 0, /* todo_flags_start */
|
|
|
801 0 /* todo_flags_finish */
|
|
|
802 }
|
|
|
803 };
|
|
|
804
|
|
|
805
|
|
|
806 /* Free all the dataflow info and the DF structure. This should be
|
|
|
807 called from the df_finish macro which also NULLs the parm. */
|
|
|
808
|
|
|
809 static unsigned int
|
|
|
810 rest_of_handle_df_finish (void)
|
|
|
811 {
|
|
|
812 int i;
|
|
|
813
|
|
|
814 gcc_assert (df);
|
|
|
815
|
|
|
816 for (i = 0; i < df->num_problems_defined; i++)
|
|
|
817 {
|
|
|
818 struct dataflow *dflow = df->problems_in_order[i];
|
|
|
819 dflow->problem->free_fun ();
|
|
|
820 }
|
|
|
821
|
|
|
822 if (df->postorder)
|
|
|
823 free (df->postorder);
|
|
|
824 if (df->postorder_inverted)
|
|
|
825 free (df->postorder_inverted);
|
|
|
826 free (df->hard_regs_live_count);
|
|
|
827 free (df);
|
|
|
828 df = NULL;
|
|
|
829
|
|
|
830 bitmap_obstack_release (&df_bitmap_obstack);
|
|
|
831 return 0;
|
|
|
832 }
|
|
|
833
|
|
|
834
|
|
|
835 struct rtl_opt_pass pass_df_finish =
|
|
|
836 {
|
|
|
837 {
|
|
|
838 RTL_PASS,
|
|
|
839 "dfinish", /* name */
|
|
|
840 NULL, /* gate */
|
|
|
841 rest_of_handle_df_finish, /* execute */
|
|
|
842 NULL, /* sub */
|
|
|
843 NULL, /* next */
|
|
|
844 0, /* static_pass_number */
|
|
|
845 0, /* tv_id */
|
|
|
846 0, /* properties_required */
|
|
|
847 0, /* properties_provided */
|
|
|
848 0, /* properties_destroyed */
|
|
|
849 0, /* todo_flags_start */
|
|
|
850 0 /* todo_flags_finish */
|
|
|
851 }
|
|
|
852 };
|
|
|
853
|
|
|
854
|
|
|
855
|
|
|
856
|
|
|
857
|
|
|
858 /*----------------------------------------------------------------------------
|
|
|
859 The general data flow analysis engine.
|
|
|
860 ----------------------------------------------------------------------------*/
|
|
|
861
|
|
|
862
|
|
|
863 /* Helper function for df_worklist_dataflow.
|
|
|
864 Propagate the dataflow forward.
|
|
|
865 Given a BB_INDEX, do the dataflow propagation
|
|
|
866 and set bits on for successors in PENDING
|
|
|
867 if the out set of the dataflow has changed. */
|
|
|
868
|
|
|
869 static void
|
|
|
870 df_worklist_propagate_forward (struct dataflow *dataflow,
|
|
|
871 unsigned bb_index,
|
|
|
872 unsigned *bbindex_to_postorder,
|
|
|
873 bitmap pending,
|
|
|
874 sbitmap considered)
|
|
|
875 {
|
|
|
876 edge e;
|
|
|
877 edge_iterator ei;
|
|
|
878 basic_block bb = BASIC_BLOCK (bb_index);
|
|
|
879
|
|
|
880 /* Calculate <conf_op> of incoming edges. */
|
|
|
881 if (EDGE_COUNT (bb->preds) > 0)
|
|
|
882 FOR_EACH_EDGE (e, ei, bb->preds)
|
|
|
883 {
|
|
|
884 if (TEST_BIT (considered, e->src->index))
|
|
|
885 dataflow->problem->con_fun_n (e);
|
|
|
886 }
|
|
|
887 else if (dataflow->problem->con_fun_0)
|
|
|
888 dataflow->problem->con_fun_0 (bb);
|
|
|
889
|
|
|
890 if (dataflow->problem->trans_fun (bb_index))
|
|
|
891 {
|
|
|
892 /* The out set of this block has changed.
|
|
|
893 Propagate to the outgoing blocks. */
|
|
|
894 FOR_EACH_EDGE (e, ei, bb->succs)
|
|
|
895 {
|
|
|
896 unsigned ob_index = e->dest->index;
|
|
|
897
|
|
|
898 if (TEST_BIT (considered, ob_index))
|
|
|
899 bitmap_set_bit (pending, bbindex_to_postorder[ob_index]);
|
|
|
900 }
|
|
|
901 }
|
|
|
902 }
|
|
|
903
|
|
|
904
|
|
|
905 /* Helper function for df_worklist_dataflow.
|
|
|
906 Propagate the dataflow backward. */
|
|
|
907
|
|
|
908 static void
|
|
|
909 df_worklist_propagate_backward (struct dataflow *dataflow,
|
|
|
910 unsigned bb_index,
|
|
|
911 unsigned *bbindex_to_postorder,
|
|
|
912 bitmap pending,
|
|
|
913 sbitmap considered)
|
|
|
914 {
|
|
|
915 edge e;
|
|
|
916 edge_iterator ei;
|
|
|
917 basic_block bb = BASIC_BLOCK (bb_index);
|
|
|
918
|
|
|
919 /* Calculate <conf_op> of incoming edges. */
|
|
|
920 if (EDGE_COUNT (bb->succs) > 0)
|
|
|
921 FOR_EACH_EDGE (e, ei, bb->succs)
|
|
|
922 {
|
|
|
923 if (TEST_BIT (considered, e->dest->index))
|
|
|
924 dataflow->problem->con_fun_n (e);
|
|
|
925 }
|
|
|
926 else if (dataflow->problem->con_fun_0)
|
|
|
927 dataflow->problem->con_fun_0 (bb);
|
|
|
928
|
|
|
929 if (dataflow->problem->trans_fun (bb_index))
|
|
|
930 {
|
|
|
931 /* The out set of this block has changed.
|
|
|
932 Propagate to the outgoing blocks. */
|
|
|
933 FOR_EACH_EDGE (e, ei, bb->preds)
|
|
|
934 {
|
|
|
935 unsigned ob_index = e->src->index;
|
|
|
936
|
|
|
937 if (TEST_BIT (considered, ob_index))
|
|
|
938 bitmap_set_bit (pending, bbindex_to_postorder[ob_index]);
|
|
|
939 }
|
|
|
940 }
|
|
|
941 }
|
|
|
942
|
|
|
943
|
|
|
944
|
|
|
945 /* This will free "pending". */
|
|
|
946
|
|
|
947 static void
|
|
|
948 df_worklist_dataflow_doublequeue (struct dataflow *dataflow,
|
|
|
949 bitmap pending,
|
|
|
950 sbitmap considered,
|
|
|
951 int *blocks_in_postorder,
|
|
|
952 unsigned *bbindex_to_postorder)
|
|
|
953 {
|
|
|
954 enum df_flow_dir dir = dataflow->problem->dir;
|
|
|
955 int dcount = 0;
|
|
|
956 bitmap worklist = BITMAP_ALLOC (&df_bitmap_obstack);
|
|
|
957
|
|
|
958 /* Double-queueing. Worklist is for the current iteration,
|
|
|
959 and pending is for the next. */
|
|
|
960 while (!bitmap_empty_p (pending))
|
|
|
961 {
|
|
|
962 /* Swap pending and worklist. */
|
|
|
963 bitmap temp = worklist;
|
|
|
964 worklist = pending;
|
|
|
965 pending = temp;
|
|
|
966
|
|
|
967 do
|
|
|
968 {
|
|
|
969 int index;
|
|
|
970 unsigned bb_index;
|
|
|
971 dcount++;
|
|
|
972
|
|
|
973 index = bitmap_first_set_bit (worklist);
|
|
|
974 bitmap_clear_bit (worklist, index);
|
|
|
975
|
|
|
976 bb_index = blocks_in_postorder[index];
|
|
|
977
|
|
|
978 if (dir == DF_FORWARD)
|
|
|
979 df_worklist_propagate_forward (dataflow, bb_index,
|
|
|
980 bbindex_to_postorder,
|
|
|
981 pending, considered);
|
|
|
982 else
|
|
|
983 df_worklist_propagate_backward (dataflow, bb_index,
|
|
|
984 bbindex_to_postorder,
|
|
|
985 pending, considered);
|
|
|
986 }
|
|
|
987 while (!bitmap_empty_p (worklist));
|
|
|
988 }
|
|
|
989
|
|
|
990 BITMAP_FREE (worklist);
|
|
|
991 BITMAP_FREE (pending);
|
|
|
992
|
|
|
993 /* Dump statistics. */
|
|
|
994 if (dump_file)
|
|
|
995 fprintf (dump_file, "df_worklist_dataflow_doublequeue:"
|
|
|
996 "n_basic_blocks %d n_edges %d"
|
|
|
997 " count %d (%5.2g)\n",
|
|
|
998 n_basic_blocks, n_edges,
|
|
|
999 dcount, dcount / (float)n_basic_blocks);
|
|
|
1000 }
|
|
|
1001
|
|
|
1002 /* Worklist-based dataflow solver. It uses sbitmap as a worklist,
|
|
|
1003 with "n"-th bit representing the n-th block in the reverse-postorder order.
|
|
|
1004 The solver is a double-queue algorithm similar to the "double stack" solver
|
|
|
1005 from Cooper, Harvey and Kennedy, "Iterative data-flow analysis, Revisited".
|
|
|
1006 The only significant difference is that the worklist in this implementation
|
|
|
1007 is always sorted in RPO of the CFG visiting direction. */
|
|
|
1008
|
|
|
1009 void
|
|
|
1010 df_worklist_dataflow (struct dataflow *dataflow,
|
|
|
1011 bitmap blocks_to_consider,
|
|
|
1012 int *blocks_in_postorder,
|
|
|
1013 int n_blocks)
|
|
|
1014 {
|
|
|
1015 bitmap pending = BITMAP_ALLOC (&df_bitmap_obstack);
|
|
|
1016 sbitmap considered = sbitmap_alloc (last_basic_block);
|
|
|
1017 bitmap_iterator bi;
|
|
|
1018 unsigned int *bbindex_to_postorder;
|
|
|
1019 int i;
|
|
|
1020 unsigned int index;
|
|
|
1021 enum df_flow_dir dir = dataflow->problem->dir;
|
|
|
1022
|
|
|
1023 gcc_assert (dir != DF_NONE);
|
|
|
1024
|
|
|
1025 /* BBINDEX_TO_POSTORDER maps the bb->index to the reverse postorder. */
|
|
|
1026 bbindex_to_postorder =
|
|
|
1027 (unsigned int *)xmalloc (last_basic_block * sizeof (unsigned int));
|
|
|
1028
|
|
|
1029 /* Initialize the array to an out-of-bound value. */
|
|
|
1030 for (i = 0; i < last_basic_block; i++)
|
|
|
1031 bbindex_to_postorder[i] = last_basic_block;
|
|
|
1032
|
|
|
1033 /* Initialize the considered map. */
|
|
|
1034 sbitmap_zero (considered);
|
|
|
1035 EXECUTE_IF_SET_IN_BITMAP (blocks_to_consider, 0, index, bi)
|
|
|
1036 {
|
|
|
1037 SET_BIT (considered, index);
|
|
|
1038 }
|
|
|
1039
|
|
|
1040 /* Initialize the mapping of block index to postorder. */
|
|
|
1041 for (i = 0; i < n_blocks; i++)
|
|
|
1042 {
|
|
|
1043 bbindex_to_postorder[blocks_in_postorder[i]] = i;
|
|
|
1044 /* Add all blocks to the worklist. */
|
|
|
1045 bitmap_set_bit (pending, i);
|
|
|
1046 }
|
|
|
1047
|
|
|
1048 /* Initialize the problem. */
|
|
|
1049 if (dataflow->problem->init_fun)
|
|
|
1050 dataflow->problem->init_fun (blocks_to_consider);
|
|
|
1051
|
|
|
1052 /* Solve it. */
|
|
|
1053 df_worklist_dataflow_doublequeue (dataflow, pending, considered,
|
|
|
1054 blocks_in_postorder,
|
|
|
1055 bbindex_to_postorder);
|
|
|
1056
|
|
|
1057 sbitmap_free (considered);
|
|
|
1058 free (bbindex_to_postorder);
|
|
|
1059 }
|
|
|
1060
|
|
|
1061
|
|
|
1062 /* Remove the entries not in BLOCKS from the LIST of length LEN, preserving
|
|
|
1063 the order of the remaining entries. Returns the length of the resulting
|
|
|
1064 list. */
|
|
|
1065
|
|
|
1066 static unsigned
|
|
|
1067 df_prune_to_subcfg (int list[], unsigned len, bitmap blocks)
|
|
|
1068 {
|
|
|
1069 unsigned act, last;
|
|
|
1070
|
|
|
1071 for (act = 0, last = 0; act < len; act++)
|
|
|
1072 if (bitmap_bit_p (blocks, list[act]))
|
|
|
1073 list[last++] = list[act];
|
|
|
1074
|
|
|
1075 return last;
|
|
|
1076 }
|
|
|
1077
|
|
|
1078
|
|
|
1079 /* Execute dataflow analysis on a single dataflow problem.
|
|
|
1080
|
|
|
1081 BLOCKS_TO_CONSIDER are the blocks whose solution can either be
|
|
|
1082 examined or will be computed. For calls from DF_ANALYZE, this is
|
|
|
1083 the set of blocks that has been passed to DF_SET_BLOCKS.
|
|
|
1084 */
|
|
|
1085
|
|
|
1086 void
|
|
|
1087 df_analyze_problem (struct dataflow *dflow,
|
|
|
1088 bitmap blocks_to_consider,
|
|
|
1089 int *postorder, int n_blocks)
|
|
|
1090 {
|
|
|
1091 timevar_push (dflow->problem->tv_id);
|
|
|
1092
|
|
|
1093 #ifdef ENABLE_DF_CHECKING
|
|
|
1094 if (dflow->problem->verify_start_fun)
|
|
|
1095 dflow->problem->verify_start_fun ();
|
|
|
1096 #endif
|
|
|
1097
|
|
|
1098 /* (Re)Allocate the datastructures necessary to solve the problem. */
|
|
|
1099 if (dflow->problem->alloc_fun)
|
|
|
1100 dflow->problem->alloc_fun (blocks_to_consider);
|
|
|
1101
|
|
|
1102 /* Set up the problem and compute the local information. */
|
|
|
1103 if (dflow->problem->local_compute_fun)
|
|
|
1104 dflow->problem->local_compute_fun (blocks_to_consider);
|
|
|
1105
|
|
|
1106 /* Solve the equations. */
|
|
|
1107 if (dflow->problem->dataflow_fun)
|
|
|
1108 dflow->problem->dataflow_fun (dflow, blocks_to_consider,
|
|
|
1109 postorder, n_blocks);
|
|
|
1110
|
|
|
1111 /* Massage the solution. */
|
|
|
1112 if (dflow->problem->finalize_fun)
|
|
|
1113 dflow->problem->finalize_fun (blocks_to_consider);
|
|
|
1114
|
|
|
1115 #ifdef ENABLE_DF_CHECKING
|
|
|
1116 if (dflow->problem->verify_end_fun)
|
|
|
1117 dflow->problem->verify_end_fun ();
|
|
|
1118 #endif
|
|
|
1119
|
|
|
1120 timevar_pop (dflow->problem->tv_id);
|
|
|
1121
|
|
|
1122 dflow->computed = true;
|
|
|
1123 }
|
|
|
1124
|
|
|
1125
|
|
|
1126 /* Analyze dataflow info for the basic blocks specified by the bitmap
|
|
|
1127 BLOCKS, or for the whole CFG if BLOCKS is zero. */
|
|
|
1128
|
|
|
1129 void
|
|
|
1130 df_analyze (void)
|
|
|
1131 {
|
|
|
1132 bitmap current_all_blocks = BITMAP_ALLOC (&df_bitmap_obstack);
|
|
|
1133 bool everything;
|
|
|
1134 int i;
|
|
|
1135
|
|
|
1136 if (df->postorder)
|
|
|
1137 free (df->postorder);
|
|
|
1138 if (df->postorder_inverted)
|
|
|
1139 free (df->postorder_inverted);
|
|
|
1140 df->postorder = XNEWVEC (int, last_basic_block);
|
|
|
1141 df->postorder_inverted = XNEWVEC (int, last_basic_block);
|
|
|
1142 df->n_blocks = post_order_compute (df->postorder, true, true);
|
|
|
1143 df->n_blocks_inverted = inverted_post_order_compute (df->postorder_inverted);
|
|
|
1144
|
|
|
1145 /* These should be the same. */
|
|
|
1146 gcc_assert (df->n_blocks == df->n_blocks_inverted);
|
|
|
1147
|
|
|
1148 /* We need to do this before the df_verify_all because this is
|
|
|
1149 not kept incrementally up to date. */
|
|
|
1150 df_compute_regs_ever_live (false);
|
|
|
1151 df_process_deferred_rescans ();
|
|
|
1152
|
|
|
1153 if (dump_file)
|
|
|
1154 fprintf (dump_file, "df_analyze called\n");
|
|
|
1155
|
|
|
1156 #ifndef ENABLE_DF_CHECKING
|
|
|
1157 if (df->changeable_flags & DF_VERIFY_SCHEDULED)
|
|
|
1158 #endif
|
|
|
1159 df_verify ();
|
|
|
1160
|
|
|
1161 for (i = 0; i < df->n_blocks; i++)
|
|
|
1162 bitmap_set_bit (current_all_blocks, df->postorder[i]);
|
|
|
1163
|
|
|
1164 #ifdef ENABLE_CHECKING
|
|
|
1165 /* Verify that POSTORDER_INVERTED only contains blocks reachable from
|
|
|
1166 the ENTRY block. */
|
|
|
1167 for (i = 0; i < df->n_blocks_inverted; i++)
|
|
|
1168 gcc_assert (bitmap_bit_p (current_all_blocks, df->postorder_inverted[i]));
|
|
|
1169 #endif
|
|
|
1170
|
|
|
1171 /* Make sure that we have pruned any unreachable blocks from these
|
|
|
1172 sets. */
|
|
|
1173 if (df->analyze_subset)
|
|
|
1174 {
|
|
|
1175 everything = false;
|
|
|
1176 bitmap_and_into (df->blocks_to_analyze, current_all_blocks);
|
|
|
1177 df->n_blocks = df_prune_to_subcfg (df->postorder,
|
|
|
1178 df->n_blocks, df->blocks_to_analyze);
|
|
|
1179 df->n_blocks_inverted = df_prune_to_subcfg (df->postorder_inverted,
|
|
|
1180 df->n_blocks_inverted,
|
|
|
1181 df->blocks_to_analyze);
|
|
|
1182 BITMAP_FREE (current_all_blocks);
|
|
|
1183 }
|
|
|
1184 else
|
|
|
1185 {
|
|
|
1186 everything = true;
|
|
|
1187 df->blocks_to_analyze = current_all_blocks;
|
|
|
1188 current_all_blocks = NULL;
|
|
|
1189 }
|
|
|
1190
|
|
|
1191 /* Skip over the DF_SCAN problem. */
|
|
|
1192 for (i = 1; i < df->num_problems_defined; i++)
|
|
|
1193 {
|
|
|
1194 struct dataflow *dflow = df->problems_in_order[i];
|
|
|
1195 if (dflow->solutions_dirty)
|
|
|
1196 {
|
|
|
1197 if (dflow->problem->dir == DF_FORWARD)
|
|
|
1198 df_analyze_problem (dflow,
|
|
|
1199 df->blocks_to_analyze,
|
|
|
1200 df->postorder_inverted,
|
|
|
1201 df->n_blocks_inverted);
|
|
|
1202 else
|
|
|
1203 df_analyze_problem (dflow,
|
|
|
1204 df->blocks_to_analyze,
|
|
|
1205 df->postorder,
|
|
|
1206 df->n_blocks);
|
|
|
1207 }
|
|
|
1208 }
|
|
|
1209
|
|
|
1210 if (everything)
|
|
|
1211 {
|
|
|
1212 BITMAP_FREE (df->blocks_to_analyze);
|
|
|
1213 df->blocks_to_analyze = NULL;
|
|
|
1214 }
|
|
|
1215
|
|
|
1216 #ifdef DF_DEBUG_CFG
|
|
|
1217 df_set_clean_cfg ();
|
|
|
1218 #endif
|
|
|
1219 }
|
|
|
1220
|
|
|
1221
|
|
|
1222 /* Return the number of basic blocks from the last call to df_analyze. */
|
|
|
1223
|
|
|
1224 int
|
|
|
1225 df_get_n_blocks (enum df_flow_dir dir)
|
|
|
1226 {
|
|
|
1227 gcc_assert (dir != DF_NONE);
|
|
|
1228
|
|
|
1229 if (dir == DF_FORWARD)
|
|
|
1230 {
|
|
|
1231 gcc_assert (df->postorder_inverted);
|
|
|
1232 return df->n_blocks_inverted;
|
|
|
1233 }
|
|
|
1234
|
|
|
1235 gcc_assert (df->postorder);
|
|
|
1236 return df->n_blocks;
|
|
|
1237 }
|
|
|
1238
|
|
|
1239
|
|
|
1240 /* Return a pointer to the array of basic blocks in the reverse postorder.
|
|
|
1241 Depending on the direction of the dataflow problem,
|
|
|
1242 it returns either the usual reverse postorder array
|
|
|
1243 or the reverse postorder of inverted traversal. */
|
|
|
1244 int *
|
|
|
1245 df_get_postorder (enum df_flow_dir dir)
|
|
|
1246 {
|
|
|
1247 gcc_assert (dir != DF_NONE);
|
|
|
1248
|
|
|
1249 if (dir == DF_FORWARD)
|
|
|
1250 {
|
|
|
1251 gcc_assert (df->postorder_inverted);
|
|
|
1252 return df->postorder_inverted;
|
|
|
1253 }
|
|
|
1254 gcc_assert (df->postorder);
|
|
|
1255 return df->postorder;
|
|
|
1256 }
|
|
|
1257
|
|
|
1258 static struct df_problem user_problem;
|
|
|
1259 static struct dataflow user_dflow;
|
|
|
1260
|
|
|
1261 /* Interface for calling iterative dataflow with user defined
|
|
|
1262 confluence and transfer functions. All that is necessary is to
|
|
|
1263 supply DIR, a direction, CONF_FUN_0, a confluence function for
|
|
|
1264 blocks with no logical preds (or NULL), CONF_FUN_N, the normal
|
|
|
1265 confluence function, TRANS_FUN, the basic block transfer function,
|
|
|
1266 and BLOCKS, the set of blocks to examine, POSTORDER the blocks in
|
|
|
1267 postorder, and N_BLOCKS, the number of blocks in POSTORDER. */
|
|
|
1268
|
|
|
1269 void
|
|
|
1270 df_simple_dataflow (enum df_flow_dir dir,
|
|
|
1271 df_init_function init_fun,
|
|
|
1272 df_confluence_function_0 con_fun_0,
|
|
|
1273 df_confluence_function_n con_fun_n,
|
|
|
1274 df_transfer_function trans_fun,
|
|
|
1275 bitmap blocks, int * postorder, int n_blocks)
|
|
|
1276 {
|
|
|
1277 memset (&user_problem, 0, sizeof (struct df_problem));
|
|
|
1278 user_problem.dir = dir;
|
|
|
1279 user_problem.init_fun = init_fun;
|
|
|
1280 user_problem.con_fun_0 = con_fun_0;
|
|
|
1281 user_problem.con_fun_n = con_fun_n;
|
|
|
1282 user_problem.trans_fun = trans_fun;
|
|
|
1283 user_dflow.problem = &user_problem;
|
|
|
1284 df_worklist_dataflow (&user_dflow, blocks, postorder, n_blocks);
|
|
|
1285 }
|
|
|
1286
|
|
|
1287
|
|
|
1288
|
|
|
1289 /*----------------------------------------------------------------------------
|
|
|
1290 Functions to support limited incremental change.
|
|
|
1291 ----------------------------------------------------------------------------*/
|
|
|
1292
|
|
|
1293
|
|
|
1294 /* Get basic block info. */
|
|
|
1295
|
|
|
1296 static void *
|
|
|
1297 df_get_bb_info (struct dataflow *dflow, unsigned int index)
|
|
|
1298 {
|
|
|
1299 if (dflow->block_info == NULL)
|
|
|
1300 return NULL;
|
|
|
1301 if (index >= dflow->block_info_size)
|
|
|
1302 return NULL;
|
|
|
1303 return (struct df_scan_bb_info *) dflow->block_info[index];
|
|
|
1304 }
|
|
|
1305
|
|
|
1306
|
|
|
1307 /* Set basic block info. */
|
|
|
1308
|
|
|
1309 static void
|
|
|
1310 df_set_bb_info (struct dataflow *dflow, unsigned int index,
|
|
|
1311 void *bb_info)
|
|
|
1312 {
|
|
|
1313 gcc_assert (dflow->block_info);
|
|
|
1314 dflow->block_info[index] = bb_info;
|
|
|
1315 }
|
|
|
1316
|
|
|
1317
|
|
|
1318 /* Mark the solutions as being out of date. */
|
|
|
1319
|
|
|
1320 void
|
|
|
1321 df_mark_solutions_dirty (void)
|
|
|
1322 {
|
|
|
1323 if (df)
|
|
|
1324 {
|
|
|
1325 int p;
|
|
|
1326 for (p = 1; p < df->num_problems_defined; p++)
|
|
|
1327 df->problems_in_order[p]->solutions_dirty = true;
|
|
|
1328 }
|
|
|
1329 }
|
|
|
1330
|
|
|
1331
|
|
|
1332 /* Return true if BB needs it's transfer functions recomputed. */
|
|
|
1333
|
|
|
1334 bool
|
|
|
1335 df_get_bb_dirty (basic_block bb)
|
|
|
1336 {
|
|
|
1337 if (df && df_live)
|
|
|
1338 return bitmap_bit_p (df_live->out_of_date_transfer_functions, bb->index);
|
|
|
1339 else
|
|
|
1340 return false;
|
|
|
1341 }
|
|
|
1342
|
|
|
1343
|
|
|
1344 /* Mark BB as needing it's transfer functions as being out of
|
|
|
1345 date. */
|
|
|
1346
|
|
|
1347 void
|
|
|
1348 df_set_bb_dirty (basic_block bb)
|
|
|
1349 {
|
|
|
1350 if (df)
|
|
|
1351 {
|
|
|
1352 int p;
|
|
|
1353 for (p = 1; p < df->num_problems_defined; p++)
|
|
|
1354 {
|
|
|
1355 struct dataflow *dflow = df->problems_in_order[p];
|
|
|
1356 if (dflow->out_of_date_transfer_functions)
|
|
|
1357 bitmap_set_bit (dflow->out_of_date_transfer_functions, bb->index);
|
|
|
1358 }
|
|
|
1359 df_mark_solutions_dirty ();
|
|
|
1360 }
|
|
|
1361 }
|
|
|
1362
|
|
|
1363
|
|
|
1364 /* Clear the dirty bits. This is called from places that delete
|
|
|
1365 blocks. */
|
|
|
1366 static void
|
|
|
1367 df_clear_bb_dirty (basic_block bb)
|
|
|
1368 {
|
|
|
1369 int p;
|
|
|
1370 for (p = 1; p < df->num_problems_defined; p++)
|
|
|
1371 {
|
|
|
1372 struct dataflow *dflow = df->problems_in_order[p];
|
|
|
1373 if (dflow->out_of_date_transfer_functions)
|
|
|
1374 bitmap_clear_bit (dflow->out_of_date_transfer_functions, bb->index);
|
|
|
1375 }
|
|
|
1376 }
|
|
|
1377 /* Called from the rtl_compact_blocks to reorganize the problems basic
|
|
|
1378 block info. */
|
|
|
1379
|
|
|
1380 void
|
|
|
1381 df_compact_blocks (void)
|
|
|
1382 {
|
|
|
1383 int i, p;
|
|
|
1384 basic_block bb;
|
|
|
1385 void **problem_temps;
|
|
|
1386 int size = last_basic_block * sizeof (void *);
|
|
|
1387 bitmap tmp = BITMAP_ALLOC (&df_bitmap_obstack);
|
|
|
1388 problem_temps = XNEWVAR (void *, size);
|
|
|
1389
|
|
|
1390 for (p = 0; p < df->num_problems_defined; p++)
|
|
|
1391 {
|
|
|
1392 struct dataflow *dflow = df->problems_in_order[p];
|
|
|
1393
|
|
|
1394 /* Need to reorganize the out_of_date_transfer_functions for the
|
|
|
1395 dflow problem. */
|
|
|
1396 if (dflow->out_of_date_transfer_functions)
|
|
|
1397 {
|
|
|
1398 bitmap_copy (tmp, dflow->out_of_date_transfer_functions);
|
|
|
1399 bitmap_clear (dflow->out_of_date_transfer_functions);
|
|
|
1400 if (bitmap_bit_p (tmp, ENTRY_BLOCK))
|
|
|
1401 bitmap_set_bit (dflow->out_of_date_transfer_functions, ENTRY_BLOCK);
|
|
|
1402 if (bitmap_bit_p (tmp, EXIT_BLOCK))
|
|
|
1403 bitmap_set_bit (dflow->out_of_date_transfer_functions, EXIT_BLOCK);
|
|
|
1404
|
|
|
1405 i = NUM_FIXED_BLOCKS;
|
|
|
1406 FOR_EACH_BB (bb)
|
|
|
1407 {
|
|
|
1408 if (bitmap_bit_p (tmp, bb->index))
|
|
|
1409 bitmap_set_bit (dflow->out_of_date_transfer_functions, i);
|
|
|
1410 i++;
|
|
|
1411 }
|
|
|
1412 }
|
|
|
1413
|
|
|
1414 /* Now shuffle the block info for the problem. */
|
|
|
1415 if (dflow->problem->free_bb_fun)
|
|
|
1416 {
|
|
|
1417 df_grow_bb_info (dflow);
|
|
|
1418 memcpy (problem_temps, dflow->block_info, size);
|
|
|
1419
|
|
|
1420 /* Copy the bb info from the problem tmps to the proper
|
|
|
1421 place in the block_info vector. Null out the copied
|
|
|
1422 item. The entry and exit blocks never move. */
|
|
|
1423 i = NUM_FIXED_BLOCKS;
|
|
|
1424 FOR_EACH_BB (bb)
|
|
|
1425 {
|
|
|
1426 df_set_bb_info (dflow, i, problem_temps[bb->index]);
|
|
|
1427 problem_temps[bb->index] = NULL;
|
|
|
1428 i++;
|
|
|
1429 }
|
|
|
1430 memset (dflow->block_info + i, 0,
|
|
|
1431 (last_basic_block - i) *sizeof (void *));
|
|
|
1432
|
|
|
1433 /* Free any block infos that were not copied (and NULLed).
|
|
|
1434 These are from orphaned blocks. */
|
|
|
1435 for (i = NUM_FIXED_BLOCKS; i < last_basic_block; i++)
|
|
|
1436 {
|
|
|
1437 basic_block bb = BASIC_BLOCK (i);
|
|
|
1438 if (problem_temps[i] && bb)
|
|
|
1439 dflow->problem->free_bb_fun
|
|
|
1440 (bb, problem_temps[i]);
|
|
|
1441 }
|
|
|
1442 }
|
|
|
1443 }
|
|
|
1444
|
|
|
1445 /* Shuffle the bits in the basic_block indexed arrays. */
|
|
|
1446
|
|
|
1447 if (df->blocks_to_analyze)
|
|
|
1448 {
|
|
|
1449 if (bitmap_bit_p (tmp, ENTRY_BLOCK))
|
|
|
1450 bitmap_set_bit (df->blocks_to_analyze, ENTRY_BLOCK);
|
|
|
1451 if (bitmap_bit_p (tmp, EXIT_BLOCK))
|
|
|
1452 bitmap_set_bit (df->blocks_to_analyze, EXIT_BLOCK);
|
|
|
1453 bitmap_copy (tmp, df->blocks_to_analyze);
|
|
|
1454 bitmap_clear (df->blocks_to_analyze);
|
|
|
1455 i = NUM_FIXED_BLOCKS;
|
|
|
1456 FOR_EACH_BB (bb)
|
|
|
1457 {
|
|
|
1458 if (bitmap_bit_p (tmp, bb->index))
|
|
|
1459 bitmap_set_bit (df->blocks_to_analyze, i);
|
|
|
1460 i++;
|
|
|
1461 }
|
|
|
1462 }
|
|
|
1463
|
|
|
1464 BITMAP_FREE (tmp);
|
|
|
1465
|
|
|
1466 free (problem_temps);
|
|
|
1467
|
|
|
1468 i = NUM_FIXED_BLOCKS;
|
|
|
1469 FOR_EACH_BB (bb)
|
|
|
1470 {
|
|
|
1471 SET_BASIC_BLOCK (i, bb);
|
|
|
1472 bb->index = i;
|
|
|
1473 i++;
|
|
|
1474 }
|
|
|
1475
|
|
|
1476 gcc_assert (i == n_basic_blocks);
|
|
|
1477
|
|
|
1478 for (; i < last_basic_block; i++)
|
|
|
1479 SET_BASIC_BLOCK (i, NULL);
|
|
|
1480
|
|
|
1481 #ifdef DF_DEBUG_CFG
|
|
|
1482 if (!df_lr->solutions_dirty)
|
|
|
1483 df_set_clean_cfg ();
|
|
|
1484 #endif
|
|
|
1485 }
|
|
|
1486
|
|
|
1487
|
|
|
1488 /* Shove NEW_BLOCK in at OLD_INDEX. Called from ifcvt to hack a
|
|
|
1489 block. There is no excuse for people to do this kind of thing. */
|
|
|
1490
|
|
|
1491 void
|
|
|
1492 df_bb_replace (int old_index, basic_block new_block)
|
|
|
1493 {
|
|
|
1494 int new_block_index = new_block->index;
|
|
|
1495 int p;
|
|
|
1496
|
|
|
1497 if (dump_file)
|
|
|
1498 fprintf (dump_file, "shoving block %d into %d\n", new_block_index, old_index);
|
|
|
1499
|
|
|
1500 gcc_assert (df);
|
|
|
1501 gcc_assert (BASIC_BLOCK (old_index) == NULL);
|
|
|
1502
|
|
|
1503 for (p = 0; p < df->num_problems_defined; p++)
|
|
|
1504 {
|
|
|
1505 struct dataflow *dflow = df->problems_in_order[p];
|
|
|
1506 if (dflow->block_info)
|
|
|
1507 {
|
|
|
1508 df_grow_bb_info (dflow);
|
|
|
1509 gcc_assert (df_get_bb_info (dflow, old_index) == NULL);
|
|
|
1510 df_set_bb_info (dflow, old_index,
|
|
|
1511 df_get_bb_info (dflow, new_block_index));
|
|
|
1512 }
|
|
|
1513 }
|
|
|
1514
|
|
|
1515 df_clear_bb_dirty (new_block);
|
|
|
1516 SET_BASIC_BLOCK (old_index, new_block);
|
|
|
1517 new_block->index = old_index;
|
|
|
1518 df_set_bb_dirty (BASIC_BLOCK (old_index));
|
|
|
1519 SET_BASIC_BLOCK (new_block_index, NULL);
|
|
|
1520 }
|
|
|
1521
|
|
|
1522
|
|
|
1523 /* Free all of the per basic block dataflow from all of the problems.
|
|
|
1524 This is typically called before a basic block is deleted and the
|
|
|
1525 problem will be reanalyzed. */
|
|
|
1526
|
|
|
1527 void
|
|
|
1528 df_bb_delete (int bb_index)
|
|
|
1529 {
|
|
|
1530 basic_block bb = BASIC_BLOCK (bb_index);
|
|
|
1531 int i;
|
|
|
1532
|
|
|
1533 if (!df)
|
|
|
1534 return;
|
|
|
1535
|
|
|
1536 for (i = 0; i < df->num_problems_defined; i++)
|
|
|
1537 {
|
|
|
1538 struct dataflow *dflow = df->problems_in_order[i];
|
|
|
1539 if (dflow->problem->free_bb_fun)
|
|
|
1540 {
|
|
|
1541 void *bb_info = df_get_bb_info (dflow, bb_index);
|
|
|
1542 if (bb_info)
|
|
|
1543 {
|
|
|
1544 dflow->problem->free_bb_fun (bb, bb_info);
|
|
|
1545 df_set_bb_info (dflow, bb_index, NULL);
|
|
|
1546 }
|
|
|
1547 }
|
|
|
1548 }
|
|
|
1549 df_clear_bb_dirty (bb);
|
|
|
1550 df_mark_solutions_dirty ();
|
|
|
1551 }
|
|
|
1552
|
|
|
1553
|
|
|
1554 /* Verify that there is a place for everything and everything is in
|
|
|
1555 its place. This is too expensive to run after every pass in the
|
|
|
1556 mainline. However this is an excellent debugging tool if the
|
|
|
1557 dataflow information is not being updated properly. You can just
|
|
|
1558 sprinkle calls in until you find the place that is changing an
|
|
|
1559 underlying structure without calling the proper updating
|
|
|
1560 routine. */
|
|
|
1561
|
|
|
1562 void
|
|
|
1563 df_verify (void)
|
|
|
1564 {
|
|
|
1565 df_scan_verify ();
|
|
|
1566 #ifdef ENABLE_DF_CHECKING
|
|
|
1567 df_lr_verify_transfer_functions ();
|
|
|
1568 if (df_live)
|
|
|
1569 df_live_verify_transfer_functions ();
|
|
|
1570 #endif
|
|
|
1571 }
|
|
|
1572
|
|
|
1573 #ifdef DF_DEBUG_CFG
|
|
|
1574
|
|
|
1575 /* Compute an array of ints that describes the cfg. This can be used
|
|
|
1576 to discover places where the cfg is modified by the appropriate
|
|
|
1577 calls have not been made to the keep df informed. The internals of
|
|
|
1578 this are unexciting, the key is that two instances of this can be
|
|
|
1579 compared to see if any changes have been made to the cfg. */
|
|
|
1580
|
|
|
1581 static int *
|
|
|
1582 df_compute_cfg_image (void)
|
|
|
1583 {
|
|
|
1584 basic_block bb;
|
|
|
1585 int size = 2 + (2 * n_basic_blocks);
|
|
|
1586 int i;
|
|
|
1587 int * map;
|
|
|
1588
|
|
|
1589 FOR_ALL_BB (bb)
|
|
|
1590 {
|
|
|
1591 size += EDGE_COUNT (bb->succs);
|
|
|
1592 }
|
|
|
1593
|
|
|
1594 map = XNEWVEC (int, size);
|
|
|
1595 map[0] = size;
|
|
|
1596 i = 1;
|
|
|
1597 FOR_ALL_BB (bb)
|
|
|
1598 {
|
|
|
1599 edge_iterator ei;
|
|
|
1600 edge e;
|
|
|
1601
|
|
|
1602 map[i++] = bb->index;
|
|
|
1603 FOR_EACH_EDGE (e, ei, bb->succs)
|
|
|
1604 map[i++] = e->dest->index;
|
|
|
1605 map[i++] = -1;
|
|
|
1606 }
|
|
|
1607 map[i] = -1;
|
|
|
1608 return map;
|
|
|
1609 }
|
|
|
1610
|
|
|
1611 static int *saved_cfg = NULL;
|
|
|
1612
|
|
|
1613
|
|
|
1614 /* This function compares the saved version of the cfg with the
|
|
|
1615 current cfg and aborts if the two are identical. The function
|
|
|
1616 silently returns if the cfg has been marked as dirty or the two are
|
|
|
1617 the same. */
|
|
|
1618
|
|
|
1619 void
|
|
|
1620 df_check_cfg_clean (void)
|
|
|
1621 {
|
|
|
1622 int *new_map;
|
|
|
1623
|
|
|
1624 if (!df)
|
|
|
1625 return;
|
|
|
1626
|
|
|
1627 if (df_lr->solutions_dirty)
|
|
|
1628 return;
|
|
|
1629
|
|
|
1630 if (saved_cfg == NULL)
|
|
|
1631 return;
|
|
|
1632
|
|
|
1633 new_map = df_compute_cfg_image ();
|
|
|
1634 gcc_assert (memcmp (saved_cfg, new_map, saved_cfg[0] * sizeof (int)) == 0);
|
|
|
1635 free (new_map);
|
|
|
1636 }
|
|
|
1637
|
|
|
1638
|
|
|
1639 /* This function builds a cfg fingerprint and squirrels it away in
|
|
|
1640 saved_cfg. */
|
|
|
1641
|
|
|
1642 static void
|
|
|
1643 df_set_clean_cfg (void)
|
|
|
1644 {
|
|
|
1645 if (saved_cfg)
|
|
|
1646 free (saved_cfg);
|
|
|
1647 saved_cfg = df_compute_cfg_image ();
|
|
|
1648 }
|
|
|
1649
|
|
|
1650 #endif /* DF_DEBUG_CFG */
|
|
|
1651 /*----------------------------------------------------------------------------
|
|
|
1652 PUBLIC INTERFACES TO QUERY INFORMATION.
|
|
|
1653 ----------------------------------------------------------------------------*/
|
|
|
1654
|
|
|
1655
|
|
|
1656 /* Return first def of REGNO within BB. */
|
|
|
1657
|
|
|
1658 df_ref
|
|
|
1659 df_bb_regno_first_def_find (basic_block bb, unsigned int regno)
|
|
|
1660 {
|
|
|
1661 rtx insn;
|
|
|
1662 df_ref *def_rec;
|
|
|
1663 unsigned int uid;
|
|
|
1664
|
|
|
1665 FOR_BB_INSNS (bb, insn)
|
|
|
1666 {
|
|
|
1667 if (!INSN_P (insn))
|
|
|
1668 continue;
|
|
|
1669
|
|
|
1670 uid = INSN_UID (insn);
|
|
|
1671 for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
|
|
|
1672 {
|
|
|
1673 df_ref def = *def_rec;
|
|
|
1674 if (DF_REF_REGNO (def) == regno)
|
|
|
1675 return def;
|
|
|
1676 }
|
|
|
1677 }
|
|
|
1678 return NULL;
|
|
|
1679 }
|
|
|
1680
|
|
|
1681
|
|
|
1682 /* Return last def of REGNO within BB. */
|
|
|
1683
|
|
|
1684 df_ref
|
|
|
1685 df_bb_regno_last_def_find (basic_block bb, unsigned int regno)
|
|
|
1686 {
|
|
|
1687 rtx insn;
|
|
|
1688 df_ref *def_rec;
|
|
|
1689 unsigned int uid;
|
|
|
1690
|
|
|
1691 FOR_BB_INSNS_REVERSE (bb, insn)
|
|
|
1692 {
|
|
|
1693 if (!INSN_P (insn))
|
|
|
1694 continue;
|
|
|
1695
|
|
|
1696 uid = INSN_UID (insn);
|
|
|
1697 for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
|
|
|
1698 {
|
|
|
1699 df_ref def = *def_rec;
|
|
|
1700 if (DF_REF_REGNO (def) == regno)
|
|
|
1701 return def;
|
|
|
1702 }
|
|
|
1703 }
|
|
|
1704
|
|
|
1705 return NULL;
|
|
|
1706 }
|
|
|
1707
|
|
|
1708 /* Finds the reference corresponding to the definition of REG in INSN.
|
|
|
1709 DF is the dataflow object. */
|
|
|
1710
|
|
|
1711 df_ref
|
|
|
1712 df_find_def (rtx insn, rtx reg)
|
|
|
1713 {
|
|
|
1714 unsigned int uid;
|
|
|
1715 df_ref *def_rec;
|
|
|
1716
|
|
|
1717 if (GET_CODE (reg) == SUBREG)
|
|
|
1718 reg = SUBREG_REG (reg);
|
|
|
1719 gcc_assert (REG_P (reg));
|
|
|
1720
|
|
|
1721 uid = INSN_UID (insn);
|
|
|
1722 for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
|
|
|
1723 {
|
|
|
1724 df_ref def = *def_rec;
|
|
|
1725 if (rtx_equal_p (DF_REF_REAL_REG (def), reg))
|
|
|
1726 return def;
|
|
|
1727 }
|
|
|
1728
|
|
|
1729 return NULL;
|
|
|
1730 }
|
|
|
1731
|
|
|
1732
|
|
|
1733 /* Return true if REG is defined in INSN, zero otherwise. */
|
|
|
1734
|
|
|
1735 bool
|
|
|
1736 df_reg_defined (rtx insn, rtx reg)
|
|
|
1737 {
|
|
|
1738 return df_find_def (insn, reg) != NULL;
|
|
|
1739 }
|
|
|
1740
|
|
|
1741
|
|
|
1742 /* Finds the reference corresponding to the use of REG in INSN.
|
|
|
1743 DF is the dataflow object. */
|
|
|
1744
|
|
|
1745 df_ref
|
|
|
1746 df_find_use (rtx insn, rtx reg)
|
|
|
1747 {
|
|
|
1748 unsigned int uid;
|
|
|
1749 df_ref *use_rec;
|
|
|
1750
|
|
|
1751 if (GET_CODE (reg) == SUBREG)
|
|
|
1752 reg = SUBREG_REG (reg);
|
|
|
1753 gcc_assert (REG_P (reg));
|
|
|
1754
|
|
|
1755 uid = INSN_UID (insn);
|
|
|
1756 for (use_rec = DF_INSN_UID_USES (uid); *use_rec; use_rec++)
|
|
|
1757 {
|
|
|
1758 df_ref use = *use_rec;
|
|
|
1759 if (rtx_equal_p (DF_REF_REAL_REG (use), reg))
|
|
|
1760 return use;
|
|
|
1761 }
|
|
|
1762 if (df->changeable_flags & DF_EQ_NOTES)
|
|
|
1763 for (use_rec = DF_INSN_UID_EQ_USES (uid); *use_rec; use_rec++)
|
|
|
1764 {
|
|
|
1765 df_ref use = *use_rec;
|
|
|
1766 if (rtx_equal_p (DF_REF_REAL_REG (use), reg))
|
|
|
1767 return use;
|
|
|
1768 }
|
|
|
1769 return NULL;
|
|
|
1770 }
|
|
|
1771
|
|
|
1772
|
|
|
1773 /* Return true if REG is referenced in INSN, zero otherwise. */
|
|
|
1774
|
|
|
1775 bool
|
|
|
1776 df_reg_used (rtx insn, rtx reg)
|
|
|
1777 {
|
|
|
1778 return df_find_use (insn, reg) != NULL;
|
|
|
1779 }
|
|
|
1780
|
|
|
1781
|
|
|
1782 /*----------------------------------------------------------------------------
|
|
|
1783 Debugging and printing functions.
|
|
|
1784 ----------------------------------------------------------------------------*/
|
|
|
1785
|
|
|
1786
|
|
|
1787 /* Write information about registers and basic blocks into FILE.
|
|
|
1788 This is part of making a debugging dump. */
|
|
|
1789
|
|
|
1790 void
|
|
|
1791 df_print_regset (FILE *file, bitmap r)
|
|
|
1792 {
|
|
|
1793 unsigned int i;
|
|
|
1794 bitmap_iterator bi;
|
|
|
1795
|
|
|
1796 if (r == NULL)
|
|
|
1797 fputs (" (nil)", file);
|
|
|
1798 else
|
|
|
1799 {
|
|
|
1800 EXECUTE_IF_SET_IN_BITMAP (r, 0, i, bi)
|
|
|
1801 {
|
|
|
1802 fprintf (file, " %d", i);
|
|
|
1803 if (i < FIRST_PSEUDO_REGISTER)
|
|
|
1804 fprintf (file, " [%s]", reg_names[i]);
|
|
|
1805 }
|
|
|
1806 }
|
|
|
1807 fprintf (file, "\n");
|
|
|
1808 }
|
|
|
1809
|
|
|
1810
|
|
|
1811 /* Write information about registers and basic blocks into FILE. The
|
|
|
1812 bitmap is in the form used by df_byte_lr. This is part of making a
|
|
|
1813 debugging dump. */
|
|
|
1814
|
|
|
1815 void
|
|
|
1816 df_print_byte_regset (FILE *file, bitmap r)
|
|
|
1817 {
|
|
|
1818 unsigned int max_reg = max_reg_num ();
|
|
|
1819 bitmap_iterator bi;
|
|
|
1820
|
|
|
1821 if (r == NULL)
|
|
|
1822 fputs (" (nil)", file);
|
|
|
1823 else
|
|
|
1824 {
|
|
|
1825 unsigned int i;
|
|
|
1826 for (i = 0; i < max_reg; i++)
|
|
|
1827 {
|
|
|
1828 unsigned int first = df_byte_lr_get_regno_start (i);
|
|
|
1829 unsigned int len = df_byte_lr_get_regno_len (i);
|
|
|
1830
|
|
|
1831 if (len > 1)
|
|
|
1832 {
|
|
|
1833 bool found = false;
|
|
|
1834 unsigned int j;
|
|
|
1835
|
|
|
1836 EXECUTE_IF_SET_IN_BITMAP (r, first, j, bi)
|
|
|
1837 {
|
|
|
1838 found = j < first + len;
|
|
|
1839 break;
|
|
|
1840 }
|
|
|
1841 if (found)
|
|
|
1842 {
|
|
|
1843 const char * sep = "";
|
|
|
1844 fprintf (file, " %d", i);
|
|
|
1845 if (i < FIRST_PSEUDO_REGISTER)
|
|
|
1846 fprintf (file, " [%s]", reg_names[i]);
|
|
|
1847 fprintf (file, "(");
|
|
|
1848 EXECUTE_IF_SET_IN_BITMAP (r, first, j, bi)
|
|
|
1849 {
|
|
|
1850 if (j > first + len - 1)
|
|
|
1851 break;
|
|
|
1852 fprintf (file, "%s%d", sep, j-first);
|
|
|
1853 sep = ", ";
|
|
|
1854 }
|
|
|
1855 fprintf (file, ")");
|
|
|
1856 }
|
|
|
1857 }
|
|
|
1858 else
|
|
|
1859 {
|
|
|
1860 if (bitmap_bit_p (r, first))
|
|
|
1861 {
|
|
|
1862 fprintf (file, " %d", i);
|
|
|
1863 if (i < FIRST_PSEUDO_REGISTER)
|
|
|
1864 fprintf (file, " [%s]", reg_names[i]);
|
|
|
1865 }
|
|
|
1866 }
|
|
|
1867
|
|
|
1868 }
|
|
|
1869 }
|
|
|
1870 fprintf (file, "\n");
|
|
|
1871 }
|
|
|
1872
|
|
|
1873
|
|
|
1874 /* Dump dataflow info. */
|
|
|
1875
|
|
|
1876 void
|
|
|
1877 df_dump (FILE *file)
|
|
|
1878 {
|
|
|
1879 basic_block bb;
|
|
|
1880 df_dump_start (file);
|
|
|
1881
|
|
|
1882 FOR_ALL_BB (bb)
|
|
|
1883 {
|
|
|
1884 df_print_bb_index (bb, file);
|
|
|
1885 df_dump_top (bb, file);
|
|
|
1886 df_dump_bottom (bb, file);
|
|
|
1887 }
|
|
|
1888
|
|
|
1889 fprintf (file, "\n");
|
|
|
1890 }
|
|
|
1891
|
|
|
1892
|
|
|
1893 /* Dump dataflow info for df->blocks_to_analyze. */
|
|
|
1894
|
|
|
1895 void
|
|
|
1896 df_dump_region (FILE *file)
|
|
|
1897 {
|
|
|
1898 if (df->blocks_to_analyze)
|
|
|
1899 {
|
|
|
1900 bitmap_iterator bi;
|
|
|
1901 unsigned int bb_index;
|
|
|
1902
|
|
|
1903 fprintf (file, "\n\nstarting region dump\n");
|
|
|
1904 df_dump_start (file);
|
|
|
1905
|
|
|
1906 EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, bb_index, bi)
|
|
|
1907 {
|
|
|
1908 basic_block bb = BASIC_BLOCK (bb_index);
|
|
|
1909
|
|
|
1910 df_print_bb_index (bb, file);
|
|
|
1911 df_dump_top (bb, file);
|
|
|
1912 df_dump_bottom (bb, file);
|
|
|
1913 }
|
|
|
1914 fprintf (file, "\n");
|
|
|
1915 }
|
|
|
1916 else
|
|
|
1917 df_dump (file);
|
|
|
1918 }
|
|
|
1919
|
|
|
1920
|
|
|
1921 /* Dump the introductory information for each problem defined. */
|
|
|
1922
|
|
|
1923 void
|
|
|
1924 df_dump_start (FILE *file)
|
|
|
1925 {
|
|
|
1926 int i;
|
|
|
1927
|
|
|
1928 if (!df || !file)
|
|
|
1929 return;
|
|
|
1930
|
|
|
1931 fprintf (file, "\n\n%s\n", current_function_name ());
|
|
|
1932 fprintf (file, "\nDataflow summary:\n");
|
|
|
1933 if (df->blocks_to_analyze)
|
|
|
1934 fprintf (file, "def_info->table_size = %d, use_info->table_size = %d\n",
|
|
|
1935 DF_DEFS_TABLE_SIZE (), DF_USES_TABLE_SIZE ());
|
|
|
1936
|
|
|
1937 for (i = 0; i < df->num_problems_defined; i++)
|
|
|
1938 {
|
|
|
1939 struct dataflow *dflow = df->problems_in_order[i];
|
|
|
1940 if (dflow->computed)
|
|
|
1941 {
|
|
|
1942 df_dump_problem_function fun = dflow->problem->dump_start_fun;
|
|
|
1943 if (fun)
|
|
|
1944 fun(file);
|
|
|
1945 }
|
|
|
1946 }
|
|
|
1947 }
|
|
|
1948
|
|
|
1949
|
|
|
1950 /* Dump the top of the block information for BB. */
|
|
|
1951
|
|
|
1952 void
|
|
|
1953 df_dump_top (basic_block bb, FILE *file)
|
|
|
1954 {
|
|
|
1955 int i;
|
|
|
1956
|
|
|
1957 if (!df || !file)
|
|
|
1958 return;
|
|
|
1959
|
|
|
1960 for (i = 0; i < df->num_problems_defined; i++)
|
|
|
1961 {
|
|
|
1962 struct dataflow *dflow = df->problems_in_order[i];
|
|
|
1963 if (dflow->computed)
|
|
|
1964 {
|
|
|
1965 df_dump_bb_problem_function bbfun = dflow->problem->dump_top_fun;
|
|
|
1966 if (bbfun)
|
|
|
1967 bbfun (bb, file);
|
|
|
1968 }
|
|
|
1969 }
|
|
|
1970 }
|
|
|
1971
|
|
|
1972
|
|
|
1973 /* Dump the bottom of the block information for BB. */
|
|
|
1974
|
|
|
1975 void
|
|
|
1976 df_dump_bottom (basic_block bb, FILE *file)
|
|
|
1977 {
|
|
|
1978 int i;
|
|
|
1979
|
|
|
1980 if (!df || !file)
|
|
|
1981 return;
|
|
|
1982
|
|
|
1983 for (i = 0; i < df->num_problems_defined; i++)
|
|
|
1984 {
|
|
|
1985 struct dataflow *dflow = df->problems_in_order[i];
|
|
|
1986 if (dflow->computed)
|
|
|
1987 {
|
|
|
1988 df_dump_bb_problem_function bbfun = dflow->problem->dump_bottom_fun;
|
|
|
1989 if (bbfun)
|
|
|
1990 bbfun (bb, file);
|
|
|
1991 }
|
|
|
1992 }
|
|
|
1993 }
|
|
|
1994
|
|
|
1995
|
|
|
1996 void
|
|
|
1997 df_refs_chain_dump (df_ref *ref_rec, bool follow_chain, FILE *file)
|
|
|
1998 {
|
|
|
1999 fprintf (file, "{ ");
|
|
|
2000 while (*ref_rec)
|
|
|
2001 {
|
|
|
2002 df_ref ref = *ref_rec;
|
|
|
2003 fprintf (file, "%c%d(%d)",
|
|
|
2004 DF_REF_REG_DEF_P (ref) ? 'd' : (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE) ? 'e' : 'u',
|
|
|
2005 DF_REF_ID (ref),
|
|
|
2006 DF_REF_REGNO (ref));
|
|
|
2007 if (follow_chain)
|
|
|
2008 df_chain_dump (DF_REF_CHAIN (ref), file);
|
|
|
2009 ref_rec++;
|
|
|
2010 }
|
|
|
2011 fprintf (file, "}");
|
|
|
2012 }
|
|
|
2013
|
|
|
2014
|
|
|
2015 /* Dump either a ref-def or reg-use chain. */
|
|
|
2016
|
|
|
2017 void
|
|
|
2018 df_regs_chain_dump (df_ref ref, FILE *file)
|
|
|
2019 {
|
|
|
2020 fprintf (file, "{ ");
|
|
|
2021 while (ref)
|
|
|
2022 {
|
|
|
2023 fprintf (file, "%c%d(%d) ",
|
|
|
2024 DF_REF_REG_DEF_P (ref) ? 'd' : 'u',
|
|
|
2025 DF_REF_ID (ref),
|
|
|
2026 DF_REF_REGNO (ref));
|
|
|
2027 ref = DF_REF_NEXT_REG (ref);
|
|
|
2028 }
|
|
|
2029 fprintf (file, "}");
|
|
|
2030 }
|
|
|
2031
|
|
|
2032
|
|
|
2033 static void
|
|
|
2034 df_mws_dump (struct df_mw_hardreg **mws, FILE *file)
|
|
|
2035 {
|
|
|
2036 while (*mws)
|
|
|
2037 {
|
|
|
2038 fprintf (file, "mw %c r[%d..%d]\n",
|
|
|
2039 (DF_MWS_REG_DEF_P (*mws)) ? 'd' : 'u',
|
|
|
2040 (*mws)->start_regno, (*mws)->end_regno);
|
|
|
2041 mws++;
|
|
|
2042 }
|
|
|
2043 }
|
|
|
2044
|
|
|
2045
|
|
|
2046 static void
|
|
|
2047 df_insn_uid_debug (unsigned int uid,
|
|
|
2048 bool follow_chain, FILE *file)
|
|
|
2049 {
|
|
|
2050 fprintf (file, "insn %d luid %d",
|
|
|
2051 uid, DF_INSN_UID_LUID (uid));
|
|
|
2052
|
|
|
2053 if (DF_INSN_UID_DEFS (uid))
|
|
|
2054 {
|
|
|
2055 fprintf (file, " defs ");
|
|
|
2056 df_refs_chain_dump (DF_INSN_UID_DEFS (uid), follow_chain, file);
|
|
|
2057 }
|
|
|
2058
|
|
|
2059 if (DF_INSN_UID_USES (uid))
|
|
|
2060 {
|
|
|
2061 fprintf (file, " uses ");
|
|
|
2062 df_refs_chain_dump (DF_INSN_UID_USES (uid), follow_chain, file);
|
|
|
2063 }
|
|
|
2064
|
|
|
2065 if (DF_INSN_UID_EQ_USES (uid))
|
|
|
2066 {
|
|
|
2067 fprintf (file, " eq uses ");
|
|
|
2068 df_refs_chain_dump (DF_INSN_UID_EQ_USES (uid), follow_chain, file);
|
|
|
2069 }
|
|
|
2070
|
|
|
2071 if (DF_INSN_UID_MWS (uid))
|
|
|
2072 {
|
|
|
2073 fprintf (file, " mws ");
|
|
|
2074 df_mws_dump (DF_INSN_UID_MWS (uid), file);
|
|
|
2075 }
|
|
|
2076 fprintf (file, "\n");
|
|
|
2077 }
|
|
|
2078
|
|
|
2079
|
|
|
2080 void
|
|
|
2081 df_insn_debug (rtx insn, bool follow_chain, FILE *file)
|
|
|
2082 {
|
|
|
2083 df_insn_uid_debug (INSN_UID (insn), follow_chain, file);
|
|
|
2084 }
|
|
|
2085
|
|
|
2086 void
|
|
|
2087 df_insn_debug_regno (rtx insn, FILE *file)
|
|
|
2088 {
|
|
|
2089 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
|
|
|
2090
|
|
|
2091 fprintf (file, "insn %d bb %d luid %d defs ",
|
|
|
2092 INSN_UID (insn), BLOCK_FOR_INSN (insn)->index,
|
|
|
2093 DF_INSN_INFO_LUID (insn_info));
|
|
|
2094 df_refs_chain_dump (DF_INSN_INFO_DEFS (insn_info), false, file);
|
|
|
2095
|
|
|
2096 fprintf (file, " uses ");
|
|
|
2097 df_refs_chain_dump (DF_INSN_INFO_USES (insn_info), false, file);
|
|
|
2098
|
|
|
2099 fprintf (file, " eq_uses ");
|
|
|
2100 df_refs_chain_dump (DF_INSN_INFO_EQ_USES (insn_info), false, file);
|
|
|
2101 fprintf (file, "\n");
|
|
|
2102 }
|
|
|
2103
|
|
|
2104 void
|
|
|
2105 df_regno_debug (unsigned int regno, FILE *file)
|
|
|
2106 {
|
|
|
2107 fprintf (file, "reg %d defs ", regno);
|
|
|
2108 df_regs_chain_dump (DF_REG_DEF_CHAIN (regno), file);
|
|
|
2109 fprintf (file, " uses ");
|
|
|
2110 df_regs_chain_dump (DF_REG_USE_CHAIN (regno), file);
|
|
|
2111 fprintf (file, " eq_uses ");
|
|
|
2112 df_regs_chain_dump (DF_REG_EQ_USE_CHAIN (regno), file);
|
|
|
2113 fprintf (file, "\n");
|
|
|
2114 }
|
|
|
2115
|
|
|
2116
|
|
|
2117 void
|
|
|
2118 df_ref_debug (df_ref ref, FILE *file)
|
|
|
2119 {
|
|
|
2120 fprintf (file, "%c%d ",
|
|
|
2121 DF_REF_REG_DEF_P (ref) ? 'd' : 'u',
|
|
|
2122 DF_REF_ID (ref));
|
|
|
2123 fprintf (file, "reg %d bb %d insn %d flag 0x%x type 0x%x ",
|
|
|
2124 DF_REF_REGNO (ref),
|
|
|
2125 DF_REF_BBNO (ref),
|
|
|
2126 DF_REF_IS_ARTIFICIAL (ref) ? -1 : DF_REF_INSN_UID (ref),
|
|
|
2127 DF_REF_FLAGS (ref),
|
|
|
2128 DF_REF_TYPE (ref));
|
|
|
2129 if (DF_REF_LOC (ref))
|
|
|
2130 fprintf (file, "loc %p(%p) chain ", (void *)DF_REF_LOC (ref), (void *)*DF_REF_LOC (ref));
|
|
|
2131 else
|
|
|
2132 fprintf (file, "chain ");
|
|
|
2133 df_chain_dump (DF_REF_CHAIN (ref), file);
|
|
|
2134 fprintf (file, "\n");
|
|
|
2135 }
|
|
|
2136
|
|
|
2137 /* Functions for debugging from GDB. */
|
|
|
2138
|
|
|
2139 void
|
|
|
2140 debug_df_insn (rtx insn)
|
|
|
2141 {
|
|
|
2142 df_insn_debug (insn, true, stderr);
|
|
|
2143 debug_rtx (insn);
|
|
|
2144 }
|
|
|
2145
|
|
|
2146
|
|
|
2147 void
|
|
|
2148 debug_df_reg (rtx reg)
|
|
|
2149 {
|
|
|
2150 df_regno_debug (REGNO (reg), stderr);
|
|
|
2151 }
|
|
|
2152
|
|
|
2153
|
|
|
2154 void
|
|
|
2155 debug_df_regno (unsigned int regno)
|
|
|
2156 {
|
|
|
2157 df_regno_debug (regno, stderr);
|
|
|
2158 }
|
|
|
2159
|
|
|
2160
|
|
|
2161 void
|
|
|
2162 debug_df_ref (df_ref ref)
|
|
|
2163 {
|
|
|
2164 df_ref_debug (ref, stderr);
|
|
|
2165 }
|
|
|
2166
|
|
|
2167
|
|
|
2168 void
|
|
|
2169 debug_df_defno (unsigned int defno)
|
|
|
2170 {
|
|
|
2171 df_ref_debug (DF_DEFS_GET (defno), stderr);
|
|
|
2172 }
|
|
|
2173
|
|
|
2174
|
|
|
2175 void
|
|
|
2176 debug_df_useno (unsigned int defno)
|
|
|
2177 {
|
|
|
2178 df_ref_debug (DF_USES_GET (defno), stderr);
|
|
|
2179 }
|
|
|
2180
|
|
|
2181
|
|
|
2182 void
|
|
|
2183 debug_df_chain (struct df_link *link)
|
|
|
2184 {
|
|
|
2185 df_chain_dump (link, stderr);
|
|
|
2186 fputc ('\n', stderr);
|
|
|
2187 }
|
