projects / gcc.git / blob
? search:


b778c0f060c4c1430add2cc7632ffa393c0ab693
[gcc.git] / gcc / df.h
1 /* Form lists of pseudo register references for autoinc optimization
2 for GNU compiler. This is part of flow optimization.
3 Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009, 2010 Free Software Foundation, Inc.
5 Originally contributed by Michael P. Hayes
6 (m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
7 Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
8 and Kenneth Zadeck (zadeck@naturalbridge.com).
9
10 This file is part of GCC.
11
12 GCC is free software; you can redistribute it and/or modify it under
13 the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 3, or (at your option) any later
15 version.
16
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
25
26 #ifndef GCC_DF_H
27 #define GCC_DF_H
28
29 #include "bitmap.h"
30 #include "regset.h"
31 #include "sbitmap.h"
32 #include "basic-block.h"
33 #include "alloc-pool.h"
34 #include "timevar.h"
35
36 struct dataflow;
37 struct df;
38 struct df_problem;
39 struct df_link;
40 struct df_insn_info;
41 union df_ref_d;
42
43 /* Data flow problems. All problems must have a unique id here. */
44
45 /* Scanning is not really a dataflow problem, but it is useful to have
46 the basic block functions in the vector so that things get done in
47 a uniform manner. The last four problems can be added or deleted
48 at any time are always defined (though LIVE is always there at -O2
49 or higher); the others are always there. */
50 #define DF_SCAN 0
51 #define DF_LR 1 /* Live Registers backward. */
52 #define DF_LIVE 2 /* Live Registers & Uninitialized Registers */
53 #define DF_RD 3 /* Reaching Defs. */
54 #define DF_CHAIN 4 /* Def-Use and/or Use-Def Chains. */
55 #define DF_BYTE_LR 5 /* Subreg tracking lr. */
56 #define DF_NOTE 6 /* REG_DEF and REG_UNUSED notes. */
57 #define DF_MD 7 /* Multiple Definitions. */
58
59 #define DF_LAST_PROBLEM_PLUS1 (DF_MD + 1)
60
61 /* Dataflow direction. */
62 enum df_flow_dir
63 {
64 DF_NONE,
65 DF_FORWARD,
66 DF_BACKWARD
67 };
68
69 /* Used in the byte scanning to determine if may or must info is to be
70 returned. */
71 enum df_mm
72 {
73 DF_MM_MAY,
74 DF_MM_MUST
75 };
76
77 /* Descriminator for the various df_ref types. */
78 enum df_ref_class {DF_REF_BASE, DF_REF_ARTIFICIAL, DF_REF_REGULAR, DF_REF_EXTRACT};
79
80 /* The first of these us a set of a registers. The remaining three
81 are all uses of a register (the mem_load and mem_store relate to
82 how the register as an addressing operand). */
83 enum df_ref_type {DF_REF_REG_DEF, DF_REF_REG_USE,
84 DF_REF_REG_MEM_LOAD, DF_REF_REG_MEM_STORE};
85
86 enum df_ref_flags
87 {
88 /* This flag is set if this ref occurs inside of a conditional
89 execution instruction. */
90 DF_REF_CONDITIONAL = 1 << 0,
91
92 /* If this flag is set for an artificial use or def, that ref
93 logically happens at the top of the block. If it is not set
94 for an artificial use or def, that ref logically happens at the
95 bottom of the block. This is never set for regular refs. */
96 DF_REF_AT_TOP = 1 << 1,
97
98 /* This flag is set if the use is inside a REG_EQUAL or REG_EQUIV
99 note. */
100 DF_REF_IN_NOTE = 1 << 2,
101
102 /* This bit is true if this ref can make regs_ever_live true for
103 this regno. */
104 DF_HARD_REG_LIVE = 1 << 3,
105
106
107 /* This flag is set if this ref is a partial use or def of the
108 associated register. */
109 DF_REF_PARTIAL = 1 << 4,
110
111 /* Read-modify-write refs generate both a use and a def and
112 these are marked with this flag to show that they are not
113 independent. */
114 DF_REF_READ_WRITE = 1 << 5,
115
116 /* This flag is set if this ref, generally a def, may clobber the
117 referenced register. This is generally only set for hard
118 registers that cross a call site. With better information
119 about calls, some of these could be changed in the future to
120 DF_REF_MUST_CLOBBER. */
121 DF_REF_MAY_CLOBBER = 1 << 6,
122
123 /* This flag is set if this ref, generally a def, is a real
124 clobber. This is not currently set for registers live across a
125 call because that clobbering may or may not happen.
126
127 Most of the uses of this are with sets that have a
128 GET_CODE(..)==CLOBBER. Note that this is set even if the
129 clobber is to a subreg. So in order to tell if the clobber
130 wipes out the entire register, it is necessary to also check
131 the DF_REF_PARTIAL flag. */
132 DF_REF_MUST_CLOBBER = 1 << 7,
133
134
135 /* If the ref has one of the following two flags set, then the
136 struct df_ref can be cast to struct df_ref_extract to access
137 the width and offset fields. */
138
139 /* This flag is set if the ref contains a SIGN_EXTRACT. */
140 DF_REF_SIGN_EXTRACT = 1 << 8,
141
142 /* This flag is set if the ref contains a ZERO_EXTRACT. */
143 DF_REF_ZERO_EXTRACT = 1 << 9,
144
145 /* This flag is set if the ref contains a STRICT_LOW_PART. */
146 DF_REF_STRICT_LOW_PART = 1 << 10,
147
148 /* This flag is set if the ref contains a SUBREG. */
149 DF_REF_SUBREG = 1 << 11,
150
151
152 /* This bit is true if this ref is part of a multiword hardreg. */
153 DF_REF_MW_HARDREG = 1 << 12,
154
155 /* This flag is set if this ref is a usage of the stack pointer by
156 a function call. */
157 DF_REF_CALL_STACK_USAGE = 1 << 13,
158
159 /* This flag is used for verification of existing refs. */
160 DF_REF_REG_MARKER = 1 << 14,
161
162 /* This flag is set if this ref is inside a pre/post modify. */
163 DF_REF_PRE_POST_MODIFY = 1 << 15
164
165 };
166
167 /* The possible ordering of refs within the df_ref_info. */
168 enum df_ref_order
169 {
170 /* There is not table. */
171 DF_REF_ORDER_NO_TABLE,
172
173 /* There is a table of refs but it is not (or no longer) organized
174 by one of the following methods. */
175 DF_REF_ORDER_UNORDERED,
176 DF_REF_ORDER_UNORDERED_WITH_NOTES,
177
178 /* Organize the table by reg order, all of the refs with regno 0
179 followed by all of the refs with regno 1 ... . Within all of
180 the regs for a particular regno, the refs are unordered. */
181 DF_REF_ORDER_BY_REG,
182
183 /* For uses, the refs within eq notes may be added for
184 DF_REF_ORDER_BY_REG. */
185 DF_REF_ORDER_BY_REG_WITH_NOTES,
186
187 /* Organize the refs in insn order. The insns are ordered within a
188 block, and the blocks are ordered by FOR_ALL_BB. */
189 DF_REF_ORDER_BY_INSN,
190
191 /* For uses, the refs within eq notes may be added for
192 DF_REF_ORDER_BY_INSN. */
193 DF_REF_ORDER_BY_INSN_WITH_NOTES
194 };
195
196 /* Function prototypes added to df_problem instance. */
197
198 /* Allocate the problem specific data. */
199 typedef void (*df_alloc_function) (bitmap);
200
201 /* This function is called if the problem has global data that needs
202 to be cleared when ever the set of blocks changes. The bitmap
203 contains the set of blocks that may require special attention.
204 This call is only made if some of the blocks are going to change.
205 If everything is to be deleted, the wholesale deletion mechanisms
206 apply. */
207 typedef void (*df_reset_function) (bitmap);
208
209 /* Free the basic block info. Called from the block reordering code
210 to get rid of the blocks that have been squished down. */
211 typedef void (*df_free_bb_function) (basic_block, void *);
212
213 /* Local compute function. */
214 typedef void (*df_local_compute_function) (bitmap);
215
216 /* Init the solution specific data. */
217 typedef void (*df_init_function) (bitmap);
218
219 /* Iterative dataflow function. */
220 typedef void (*df_dataflow_function) (struct dataflow *, bitmap, int *, int);
221
222 /* Confluence operator for blocks with 0 out (or in) edges. */
223 typedef void (*df_confluence_function_0) (basic_block);
224
225 /* Confluence operator for blocks with 1 or more out (or in) edges. */
226 typedef bool (*df_confluence_function_n) (edge);
227
228 /* Transfer function for blocks. */
229 typedef bool (*df_transfer_function) (int);
230
231 /* Function to massage the information after the problem solving. */
232 typedef void (*df_finalizer_function) (bitmap);
233
234 /* Function to free all of the problem specific datastructures. */
235 typedef void (*df_free_function) (void);
236
237 /* Function to remove this problem from the stack of dataflow problems
238 without effecting the other problems in the stack except for those
239 that depend on this problem. */
240 typedef void (*df_remove_problem_function) (void);
241
242 /* Function to dump basic block independent results to FILE. */
243 typedef void (*df_dump_problem_function) (FILE *);
244
245 /* Function to dump top or bottom of basic block results to FILE. */
246 typedef void (*df_dump_bb_problem_function) (basic_block, FILE *);
247
248 /* Function to dump top or bottom of basic block results to FILE. */
249 typedef void (*df_verify_solution_start) (void);
250
251 /* Function to dump top or bottom of basic block results to FILE. */
252 typedef void (*df_verify_solution_end) (void);
253
254 /* The static description of a dataflow problem to solve. See above
255 typedefs for doc for the function fields. */
256
257 struct df_problem {
258 /* The unique id of the problem. This is used it index into
259 df->defined_problems to make accessing the problem data easy. */
260 unsigned int id;
261 enum df_flow_dir dir; /* Dataflow direction. */
262 df_alloc_function alloc_fun;
263 df_reset_function reset_fun;
264 df_free_bb_function free_bb_fun;
265 df_local_compute_function local_compute_fun;
266 df_init_function init_fun;
267 df_dataflow_function dataflow_fun;
268 df_confluence_function_0 con_fun_0;
269 df_confluence_function_n con_fun_n;
270 df_transfer_function trans_fun;
271 df_finalizer_function finalize_fun;
272 df_free_function free_fun;
273 df_remove_problem_function remove_problem_fun;
274 df_dump_problem_function dump_start_fun;
275 df_dump_bb_problem_function dump_top_fun;
276 df_dump_bb_problem_function dump_bottom_fun;
277 df_verify_solution_start verify_start_fun;
278 df_verify_solution_end verify_end_fun;
279 struct df_problem *dependent_problem;
280 unsigned int block_info_elt_size;
281
282 /* The timevar id associated with this pass. */
283 timevar_id_t tv_id;
284
285 /* True if the df_set_blocks should null out the basic block info if
286 this block drops out of df->blocks_to_analyze. */
287 bool free_blocks_on_set_blocks;
288 };
289
290
291 /* The specific instance of the problem to solve. */
292 struct dataflow
293 {
294 struct df_problem *problem; /* The problem to be solved. */
295
296 /* Array indexed by bb->index, that contains basic block problem and
297 solution specific information. */
298 void *block_info;
299 unsigned int block_info_size;
300
301 /* The pool to allocate the block_info from. */
302 alloc_pool block_pool;
303
304 /* The lr and live problems have their transfer functions recomputed
305 only if necessary. This is possible for them because, the
306 problems are kept active for the entire backend and their
307 transfer functions are indexed by the REGNO. These are not
308 defined for any other problem. */
309 bitmap out_of_date_transfer_functions;
310
311 /* Other problem specific data that is not on a per basic block
312 basis. The structure is generally defined privately for the
313 problem. The exception being the scanning problem where it is
314 fully public. */
315 void *problem_data;
316
317 /* Local flags for some of the problems. */
318 unsigned int local_flags;
319
320 /* True if this problem of this instance has been initialized. This
321 is used by the dumpers to keep garbage out of the dumps if, for
322 debugging a dump is produced before the first call to
323 df_analyze after a new problem is added. */
324 bool computed;
325
326 /* True if the something has changed which invalidates the dataflow
327 solutions. Note that this bit is always true for all problems except
328 lr and live. */
329 bool solutions_dirty;
330
331 /* If true, this pass is deleted by df_finish_pass. This is never
332 true for DF_SCAN and DF_LR. It is true for DF_LIVE if optimize >
333 1. It is always true for the other problems. */
334 bool optional_p;
335 };
336
337
338 /* The set of multiword hardregs used as operands to this
339 instruction. These are factored into individual uses and defs but
340 the aggregate is still needed to service the REG_DEAD and
341 REG_UNUSED notes. */
342 struct df_mw_hardreg
343 {
344 rtx mw_reg; /* The multiword hardreg. */
345 /* These two bitfields are intentionally oversized, in the hope that
346 accesses to 16-bit fields will usually be quicker. */
347 ENUM_BITFIELD(df_ref_type) type : 16;
348 /* Used to see if the ref is read or write. */
349 int flags : 16; /* Various df_ref_flags. */
350 unsigned int start_regno; /* First word of the multi word subreg. */
351 unsigned int end_regno; /* Last word of the multi word subreg. */
352 unsigned int mw_order; /* Same as df_ref.ref_order. */
353 };
354
355
356 /* Define a register reference structure. One of these is allocated
357 for every register reference (use or def). Note some register
358 references (e.g., post_inc, subreg) generate both a def and a use. */
359 struct df_base_ref
360 {
361 /* These three bitfields are intentionally oversized, in the hope that
362 accesses to 8 and 16-bit fields will usually be quicker. */
363 ENUM_BITFIELD(df_ref_class) cl : 8;
364
365 ENUM_BITFIELD(df_ref_type) type : 8;
366 /* Type of ref. */
367 int flags : 16; /* Various df_ref_flags. */
368 unsigned int regno; /* The register number referenced. */
369 rtx reg; /* The register referenced. */
370 struct df_link *chain; /* Head of def-use, use-def. */
371 /* Pointer to the insn info of the containing instruction. FIXME!
372 Currently this is NULL for artificial refs but this will be used
373 when FUDs are added. */
374 struct df_insn_info *insn_info;
375 /* For each regno, there are three chains of refs, one for the uses,
376 the eq_uses and the defs. These chains go thru the refs
377 themselves rather than using an external structure. */
378 union df_ref_d *next_reg; /* Next ref with same regno and type. */
379 union df_ref_d *prev_reg; /* Prev ref with same regno and type. */
380 /* Location in the ref table. This is only valid after a call to
381 df_maybe_reorganize_[use,def]_refs which is an expensive operation. */
382 int id;
383 /* The index at which the operand was scanned in the insn. This is
384 used to totally order the refs in an insn. */
385 unsigned int ref_order;
386 };
387
388
389 /* The three types of df_refs. Note that the df_ref_extract is an
390 extension of the df_regular_ref, not the df_base_ref. */
391 struct df_artificial_ref
392 {
393 struct df_base_ref base;
394
395 /* Artificial refs do not have an insn, so to get the basic block,
396 it must be explicitly here. */
397 basic_block bb;
398 };
399
400
401 struct df_regular_ref
402 {
403 struct df_base_ref base;
404 /* The loc is the address in the insn of the reg. This is not
405 defined for special registers, such as clobbers and stack
406 pointers that are also associated with call insns and so those
407 just use the base. */
408 rtx *loc;
409 };
410
411
412 /* A df_ref_extract is just a df_ref with a width and offset field at
413 the end of it. It is used to hold this information if the ref was
414 wrapped by a SIGN_EXTRACT or a ZERO_EXTRACT and to pass this info
415 to passes that wish to process partial regs precisely. */
416 struct df_extract_ref
417 {
418 struct df_regular_ref base;
419 int width;
420 int offset;
421 enum machine_mode mode;
422 };
423
424 /* Union of the different kinds of defs/uses placeholders. */
425 union df_ref_d
426 {
427 struct df_base_ref base;
428 struct df_regular_ref regular_ref;
429 struct df_artificial_ref artificial_ref;
430 struct df_extract_ref extract_ref;
431 };
432 typedef union df_ref_d *df_ref;
433
434
435 /* One of these structures is allocated for every insn. */
436 struct df_insn_info
437 {
438 rtx insn; /* The insn this info comes from. */
439 df_ref *defs; /* Head of insn-def chain. */
440 df_ref *uses; /* Head of insn-use chain. */
441 /* Head of insn-use chain for uses in REG_EQUAL/EQUIV notes. */
442 df_ref *eq_uses;
443 struct df_mw_hardreg **mw_hardregs;
444 /* The logical uid of the insn in the basic block. This is valid
445 after any call to df_analyze but may rot after insns are added,
446 deleted or moved. */
447 int luid;
448 };
449
450 /* These links are used for ref-ref chains. Currently only DEF-USE and
451 USE-DEF chains can be built by DF. */
452 struct df_link
453 {
454 df_ref ref;
455 struct df_link *next;
456 };
457
458 \f
459 enum df_chain_flags
460 {
461 /* Flags that control the building of chains. */
462 DF_DU_CHAIN = 1, /* Build DU chains. */
463 DF_UD_CHAIN = 2 /* Build UD chains. */
464 };
465
466 enum df_changeable_flags
467 {
468 /* Scanning flags. */
469 /* Flag to control the running of dce as a side effect of building LR. */
470 DF_LR_RUN_DCE = 1 << 0, /* Run DCE. */
471 DF_NO_HARD_REGS = 1 << 1, /* Skip hard registers in RD and CHAIN Building. */
472
473 DF_EQ_NOTES = 1 << 2, /* Build chains with uses present in EQUIV/EQUAL notes. */
474 DF_NO_REGS_EVER_LIVE = 1 << 3, /* Do not compute the regs_ever_live. */
475
476 /* Cause df_insn_rescan df_notes_rescan and df_insn_delete, to
477 return immediately. This is used by passes that know how to update
478 the scanning them selves. */
479 DF_NO_INSN_RESCAN = 1 << 4,
480
481 /* Cause df_insn_rescan df_notes_rescan and df_insn_delete, to
482 return after marking the insn for later processing. This allows all
483 rescans to be batched. */
484 DF_DEFER_INSN_RESCAN = 1 << 5,
485
486 DF_VERIFY_SCHEDULED = 1 << 6
487 };
488
489 /* Two of these structures are inline in df, one for the uses and one
490 for the defs. This structure is only contains the refs within the
491 boundary of the df_set_blocks if that has been defined. */
492 struct df_ref_info
493 {
494 df_ref *refs; /* Ref table, indexed by id. */
495 unsigned int *begin; /* First ref_index for this pseudo. */
496 unsigned int *count; /* Count of refs for this pseudo. */
497 unsigned int refs_size; /* Size of currently allocated refs table. */
498
499 /* Table_size is the number of elements in the refs table. This
500 will also be the width of the bitvectors in the rd and ru
501 problems. Total_size is the number of refs. These will be the
502 same if the focus has not been reduced by df_set_blocks. If the
503 focus has been reduced, table_size will be smaller since it only
504 contains the refs in the set blocks. */
505 unsigned int table_size;
506 unsigned int total_size;
507
508 enum df_ref_order ref_order;
509 };
510
511 /* Three of these structures are allocated for every pseudo reg. One
512 for the uses, one for the eq_uses and one for the defs. */
513 struct df_reg_info
514 {
515 /* Head of chain for refs of that type and regno. */
516 df_ref reg_chain;
517 /* Number of refs in the chain. */
518 unsigned int n_refs;
519 };
520
521
522 /*----------------------------------------------------------------------------
523 Problem data for the scanning dataflow problem. Unlike the other
524 dataflow problems, the problem data for scanning is fully exposed and
525 used by owners of the problem.
526 ----------------------------------------------------------------------------*/
527
528 struct df
529 {
530
531 /* The set of problems to be solved is stored in two arrays. In
532 PROBLEMS_IN_ORDER, the problems are stored in the order that they
533 are solved. This is an internally dense array that may have
534 nulls at the end of it. In PROBLEMS_BY_INDEX, the problem is
535 stored by the value in df_problem.id. These are used to access
536 the problem local data without having to search the first
537 array. */
538
539 struct dataflow *problems_in_order[DF_LAST_PROBLEM_PLUS1];
540 struct dataflow *problems_by_index[DF_LAST_PROBLEM_PLUS1];
541
542 /* If not NULL, this subset of blocks of the program to be
543 considered for analysis. At certain times, this will contain all
544 the blocks in the function so it cannot be used as an indicator
545 of if we are analyzing a subset. See analyze_subset. */
546 bitmap blocks_to_analyze;
547
548 /* The following information is really the problem data for the
549 scanning instance but it is used too often by the other problems
550 to keep getting it from there. */
551 struct df_ref_info def_info; /* Def info. */
552 struct df_ref_info use_info; /* Use info. */
553
554 /* The following three arrays are allocated in parallel. They contain
555 the sets of refs of each type for each reg. */
556 struct df_reg_info **def_regs; /* Def reg info. */
557 struct df_reg_info **use_regs; /* Eq_use reg info. */
558 struct df_reg_info **eq_use_regs; /* Eq_use info. */
559 unsigned int regs_size; /* Size of currently allocated regs table. */
560 unsigned int regs_inited; /* Number of regs with reg_infos allocated. */
561
562
563 struct df_insn_info **insns; /* Insn table, indexed by insn UID. */
564 unsigned int insns_size; /* Size of insn table. */
565
566 int num_problems_defined;
567
568 bitmap_head hardware_regs_used; /* The set of hardware registers used. */
569 /* The set of hard regs that are in the artificial uses at the end
570 of a regular basic block. */
571 bitmap_head regular_block_artificial_uses;
572 /* The set of hard regs that are in the artificial uses at the end
573 of a basic block that has an EH pred. */
574 bitmap_head eh_block_artificial_uses;
575 /* The set of hardware registers live on entry to the function. */
576 bitmap entry_block_defs;
577 bitmap exit_block_uses; /* The set of hardware registers used in exit block. */
578
579 /* Insns to delete, rescan or reprocess the notes at next
580 df_rescan_all or df_process_deferred_rescans. */
581 bitmap_head insns_to_delete;
582 bitmap_head insns_to_rescan;
583 bitmap_head insns_to_notes_rescan;
584 int *postorder; /* The current set of basic blocks
585 in reverse postorder. */
586 int *postorder_inverted; /* The current set of basic blocks
587 in reverse postorder of inverted CFG. */
588 int n_blocks; /* The number of blocks in reverse postorder. */
589 int n_blocks_inverted; /* The number of blocks
590 in reverse postorder of inverted CFG. */
591
592 /* An array [FIRST_PSEUDO_REGISTER], indexed by regno, of the number
593 of refs that qualify as being real hard regs uses. Artificial
594 uses and defs as well as refs in eq notes are ignored. If the
595 ref is a def, it cannot be a MAY_CLOBBER def. If the ref is a
596 use, it cannot be the emim_reg_set or be the frame or arg pointer
597 register.
598
599 IT IS NOT ACCEPTABLE TO MANUALLY CHANGE THIS ARRAY. This array
600 always reflects the actual number of refs in the insn stream that
601 satisfy the above criteria. */
602 unsigned int *hard_regs_live_count;
603
604 /* This counter provides a way to totally order refs without using
605 addresses. It is incremented whenever a ref is created. */
606 unsigned int ref_order;
607
608 /* Problem specific control information. This is a combination of
609 enum df_changeable_flags values. */
610 int changeable_flags : 8;
611
612 /* If this is true, then only a subset of the blocks of the program
613 is considered to compute the solutions of dataflow problems. */
614 bool analyze_subset;
615
616 /* True if someone added or deleted something from regs_ever_live so
617 that the entry and exit blocks need be reprocessed. */
618 bool redo_entry_and_exit;
619 };
620
621 #define DF_SCAN_BB_INFO(BB) (df_scan_get_bb_info((BB)->index))
622 #define DF_RD_BB_INFO(BB) (df_rd_get_bb_info((BB)->index))
623 #define DF_LR_BB_INFO(BB) (df_lr_get_bb_info((BB)->index))
624 #define DF_LIVE_BB_INFO(BB) (df_live_get_bb_info((BB)->index))
625 #define DF_BYTE_LR_BB_INFO(BB) (df_byte_lr_get_bb_info((BB)->index))
626 #define DF_MD_BB_INFO(BB) (df_md_get_bb_info((BB)->index))
627
628 /* Most transformations that wish to use live register analysis will
629 use these macros. This info is the and of the lr and live sets. */
630 #define DF_LIVE_IN(BB) (&DF_LIVE_BB_INFO(BB)->in)
631 #define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO(BB)->out)
632
633 /* These macros are used by passes that are not tolerant of
634 uninitialized variables. This intolerance should eventually
635 be fixed. */
636 #define DF_LR_IN(BB) (&DF_LR_BB_INFO(BB)->in)
637 #define DF_LR_OUT(BB) (&DF_LR_BB_INFO(BB)->out)
638
639 /* These macros are used by passes that are not tolerant of
640 uninitialized variables. This intolerance should eventually
641 be fixed. */
642 #define DF_BYTE_LR_IN(BB) (&DF_BYTE_LR_BB_INFO(BB)->in)
643 #define DF_BYTE_LR_OUT(BB) (&DF_BYTE_LR_BB_INFO(BB)->out)
644
645 /* Macros to access the elements within the ref structure. */
646
647
648 #define DF_REF_REAL_REG(REF) (GET_CODE ((REF)->base.reg) == SUBREG \
649 ? SUBREG_REG ((REF)->base.reg) : ((REF)->base.reg))
650 #define DF_REF_REGNO(REF) ((REF)->base.regno)
651 #define DF_REF_REAL_LOC(REF) (GET_CODE (*((REF)->regular_ref.loc)) == SUBREG \
652 ? &SUBREG_REG (*((REF)->regular_ref.loc)) : ((REF)->regular_ref.loc))
653 #define DF_REF_REG(REF) ((REF)->base.reg)
654 #define DF_REF_LOC(REF) ((DF_REF_CLASS(REF) == DF_REF_REGULAR || DF_REF_CLASS(REF) == DF_REF_EXTRACT) ? \
655 (REF)->regular_ref.loc : NULL)
656 #define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL(REF) ? \
657 (REF)->artificial_ref.bb : BLOCK_FOR_INSN (DF_REF_INSN(REF)))
658 #define DF_REF_BBNO(REF) (DF_REF_BB (REF)->index)
659 #define DF_REF_INSN_INFO(REF) ((REF)->base.insn_info)
660 #define DF_REF_INSN(REF) ((REF)->base.insn_info->insn)
661 #define DF_REF_INSN_UID(REF) (INSN_UID (DF_REF_INSN(REF)))
662 #define DF_REF_CLASS(REF) ((REF)->base.cl)
663 #define DF_REF_TYPE(REF) ((REF)->base.type)
664 #define DF_REF_CHAIN(REF) ((REF)->base.chain)
665 #define DF_REF_ID(REF) ((REF)->base.id)
666 #define DF_REF_FLAGS(REF) ((REF)->base.flags)
667 #define DF_REF_FLAGS_IS_SET(REF, v) ((DF_REF_FLAGS (REF) & (v)) != 0)
668 #define DF_REF_FLAGS_SET(REF, v) (DF_REF_FLAGS (REF) |= (v))
669 #define DF_REF_FLAGS_CLEAR(REF, v) (DF_REF_FLAGS (REF) &= ~(v))
670 #define DF_REF_ORDER(REF) ((REF)->base.ref_order)
671 /* If DF_REF_IS_ARTIFICIAL () is true, this is not a real
672 definition/use, but an artificial one created to model always live
673 registers, eh uses, etc. */
674 #define DF_REF_IS_ARTIFICIAL(REF) (DF_REF_CLASS(REF) == DF_REF_ARTIFICIAL)
675 #define DF_REF_REG_MARK(REF) (DF_REF_FLAGS_SET ((REF),DF_REF_REG_MARKER))
676 #define DF_REF_REG_UNMARK(REF) (DF_REF_FLAGS_CLEAR ((REF),DF_REF_REG_MARKER))
677 #define DF_REF_IS_REG_MARKED(REF) (DF_REF_FLAGS_IS_SET ((REF),DF_REF_REG_MARKER))
678 #define DF_REF_NEXT_REG(REF) ((REF)->base.next_reg)
679 #define DF_REF_PREV_REG(REF) ((REF)->base.prev_reg)
680 /* The following two macros may only be applied if one of
681 DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT is true. */
682 #define DF_REF_EXTRACT_WIDTH(REF) ((REF)->extract_ref.width)
683 #define DF_REF_EXTRACT_OFFSET(REF) ((REF)->extract_ref.offset)
684 #define DF_REF_EXTRACT_MODE(REF) ((REF)->extract_ref.mode)
685
686 /* Macros to determine the reference type. */
687 #define DF_REF_REG_DEF_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_DEF)
688 #define DF_REF_REG_USE_P(REF) ((REF) && !DF_REF_REG_DEF_P (REF))
689 #define DF_REF_REG_MEM_STORE_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_MEM_STORE)
690 #define DF_REF_REG_MEM_LOAD_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_MEM_LOAD)
691 #define DF_REF_REG_MEM_P(REF) (DF_REF_REG_MEM_STORE_P (REF) \
692 || DF_REF_REG_MEM_LOAD_P (REF))
693
694 #define DF_MWS_REG_DEF_P(MREF) (DF_MWS_TYPE (MREF) == DF_REF_REG_DEF)
695 #define DF_MWS_REG_USE_P(MREF) ((MREF) && !DF_MWS_REG_DEF_P (MREF))
696 #define DF_MWS_TYPE(MREF) ((MREF)->type)
697
698 /* Macros to get the refs out of def_info or use_info refs table. If
699 the focus of the dataflow has been set to some subset of blocks
700 with df_set_blocks, these macros will only find the uses and defs
701 in that subset of blocks.
702
703 These macros should be used with care. The def macros are only
704 usable after a call to df_maybe_reorganize_def_refs and the use
705 macros are only usable after a call to
706 df_maybe_reorganize_use_refs. HOWEVER, BUILDING AND USING THESE
707 ARRAYS ARE A CACHE LOCALITY KILLER. */
708
709 #define DF_DEFS_TABLE_SIZE() (df->def_info.table_size)
710 #define DF_DEFS_GET(ID) (df->def_info.refs[(ID)])
711 #define DF_DEFS_SET(ID,VAL) (df->def_info.refs[(ID)]=(VAL))
712 #define DF_DEFS_COUNT(ID) (df->def_info.count[(ID)])
713 #define DF_DEFS_BEGIN(ID) (df->def_info.begin[(ID)])
714 #define DF_USES_TABLE_SIZE() (df->use_info.table_size)
715 #define DF_USES_GET(ID) (df->use_info.refs[(ID)])
716 #define DF_USES_SET(ID,VAL) (df->use_info.refs[(ID)]=(VAL))
717 #define DF_USES_COUNT(ID) (df->use_info.count[(ID)])
718 #define DF_USES_BEGIN(ID) (df->use_info.begin[(ID)])
719
720 /* Macros to access the register information from scan dataflow record. */
721
722 #define DF_REG_SIZE(DF) (df->regs_inited)
723 #define DF_REG_DEF_GET(REG) (df->def_regs[(REG)])
724 #define DF_REG_DEF_CHAIN(REG) (df->def_regs[(REG)]->reg_chain)
725 #define DF_REG_DEF_COUNT(REG) (df->def_regs[(REG)]->n_refs)
726 #define DF_REG_USE_GET(REG) (df->use_regs[(REG)])
727 #define DF_REG_USE_CHAIN(REG) (df->use_regs[(REG)]->reg_chain)
728 #define DF_REG_USE_COUNT(REG) (df->use_regs[(REG)]->n_refs)
729 #define DF_REG_EQ_USE_GET(REG) (df->eq_use_regs[(REG)])
730 #define DF_REG_EQ_USE_CHAIN(REG) (df->eq_use_regs[(REG)]->reg_chain)
731 #define DF_REG_EQ_USE_COUNT(REG) (df->eq_use_regs[(REG)]->n_refs)
732
733 /* Macros to access the elements within the reg_info structure table. */
734
735 #define DF_REGNO_FIRST_DEF(REGNUM) \
736 (DF_REG_DEF_GET(REGNUM) ? DF_REG_DEF_GET(REGNUM) : 0)
737 #define DF_REGNO_LAST_USE(REGNUM) \
738 (DF_REG_USE_GET(REGNUM) ? DF_REG_USE_GET(REGNUM) : 0)
739
740 /* Macros to access the elements within the insn_info structure table. */
741
742 #define DF_INSN_SIZE() ((df)->insns_size)
743 #define DF_INSN_INFO_GET(INSN) (df->insns[(INSN_UID(INSN))])
744 #define DF_INSN_INFO_SET(INSN,VAL) (df->insns[(INSN_UID (INSN))]=(VAL))
745 #define DF_INSN_INFO_LUID(II) ((II)->luid)
746 #define DF_INSN_INFO_DEFS(II) ((II)->defs)
747 #define DF_INSN_INFO_USES(II) ((II)->uses)
748 #define DF_INSN_INFO_EQ_USES(II) ((II)->eq_uses)
749
750 #define DF_INSN_LUID(INSN) (DF_INSN_INFO_LUID (DF_INSN_INFO_GET(INSN)))
751 #define DF_INSN_DEFS(INSN) (DF_INSN_INFO_DEFS (DF_INSN_INFO_GET(INSN)))
752 #define DF_INSN_USES(INSN) (DF_INSN_INFO_USES (DF_INSN_INFO_GET(INSN)))
753 #define DF_INSN_EQ_USES(INSN) (DF_INSN_INFO_EQ_USES (DF_INSN_INFO_GET(INSN)))
754
755 #define DF_INSN_UID_GET(UID) (df->insns[(UID)])
756 #define DF_INSN_UID_SET(UID,VAL) (df->insns[(UID)]=(VAL))
757 #define DF_INSN_UID_SAFE_GET(UID) (((unsigned)(UID) < DF_INSN_SIZE()) \
758 ? DF_INSN_UID_GET (UID) \
759 : NULL)
760 #define DF_INSN_UID_LUID(INSN) (DF_INSN_UID_GET(INSN)->luid)
761 #define DF_INSN_UID_DEFS(INSN) (DF_INSN_UID_GET(INSN)->defs)
762 #define DF_INSN_UID_USES(INSN) (DF_INSN_UID_GET(INSN)->uses)
763 #define DF_INSN_UID_EQ_USES(INSN) (DF_INSN_UID_GET(INSN)->eq_uses)
764 #define DF_INSN_UID_MWS(INSN) (DF_INSN_UID_GET(INSN)->mw_hardregs)
765
766 /* An obstack for bitmap not related to specific dataflow problems.
767 This obstack should e.g. be used for bitmaps with a short life time
768 such as temporary bitmaps. This obstack is declared in df-core.c. */
769
770 extern bitmap_obstack df_bitmap_obstack;
771
772
773 /* One of these structures is allocated for every basic block. */
774 struct df_scan_bb_info
775 {
776 /* The entry block has many artificial defs and these are at the
777 bottom of the block.
778
779 Blocks that are targets of exception edges may have some
780 artificial defs. These are logically located at the top of the
781 block.
782
783 Blocks that are the targets of non-local goto's have the hard
784 frame pointer defined at the top of the block. */
785 df_ref *artificial_defs;
786
787 /* Blocks that are targets of exception edges may have some
788 artificial uses. These are logically at the top of the block.
789
790 Most blocks have artificial uses at the bottom of the block. */
791 df_ref *artificial_uses;
792 };
793
794
795 /* Reaching definitions. All bitmaps are indexed by the id field of
796 the ref except sparse_kill which is indexed by regno. */
797 struct df_rd_bb_info
798 {
799 /* Local sets to describe the basic blocks. */
800 bitmap_head kill;
801 bitmap_head sparse_kill;
802 bitmap_head gen; /* The set of defs generated in this block. */
803
804 /* The results of the dataflow problem. */
805 bitmap_head in; /* At the top of the block. */
806 bitmap_head out; /* At the bottom of the block. */
807 };
808
809
810 /* Multiple reaching definitions. All bitmaps are referenced by the
811 register number. */
812
813 struct df_md_bb_info
814 {
815 /* Local sets to describe the basic blocks. */
816 bitmap_head gen; /* Partial/conditional definitions live at BB out. */
817 bitmap_head kill; /* Other definitions that are live at BB out. */
818 bitmap_head init; /* Definitions coming from dominance frontier edges. */
819
820 /* The results of the dataflow problem. */
821 bitmap_head in; /* Just before the block itself. */
822 bitmap_head out; /* At the bottom of the block. */
823 };
824
825
826 /* Live registers, a backwards dataflow problem. All bitmaps are
827 referenced by the register number. */
828
829 struct df_lr_bb_info
830 {
831 /* Local sets to describe the basic blocks. */
832 bitmap_head def; /* The set of registers set in this block
833 - except artificial defs at the top. */
834 bitmap_head use; /* The set of registers used in this block. */
835
836 /* The results of the dataflow problem. */
837 bitmap_head in; /* Just before the block itself. */
838 bitmap_head out; /* At the bottom of the block. */
839 };
840
841
842 /* Uninitialized registers. All bitmaps are referenced by the
843 register number. Anded results of the forwards and backward live
844 info. Note that the forwards live information is not available
845 separately. */
846 struct df_live_bb_info
847 {
848 /* Local sets to describe the basic blocks. */
849 bitmap_head kill; /* The set of registers unset in this block. Calls,
850 for instance, unset registers. */
851 bitmap_head gen; /* The set of registers set in this block. */
852
853 /* The results of the dataflow problem. */
854 bitmap_head in; /* At the top of the block. */
855 bitmap_head out; /* At the bottom of the block. */
856 };
857
858
859 /* Live registers, a backwards dataflow problem. These bitmaps are
860 indexed by the df_byte_lr_offset array which is indexed by pseudo. */
861
862 struct df_byte_lr_bb_info
863 {
864 /* Local sets to describe the basic blocks. */
865 bitmap_head def; /* The set of registers set in this block
866 - except artificial defs at the top. */
867 bitmap_head use; /* The set of registers used in this block. */
868
869 /* The results of the dataflow problem. */
870 bitmap_head in; /* Just before the block itself. */
871 bitmap_head out; /* At the bottom of the block. */
872 };
873
874
875 /* This is used for debugging and for the dumpers to find the latest
876 instance so that the df info can be added to the dumps. This
877 should not be used by regular code. */
878 extern struct df *df;
879 #define df_scan (df->problems_by_index[DF_SCAN])
880 #define df_rd (df->problems_by_index[DF_RD])
881 #define df_lr (df->problems_by_index[DF_LR])
882 #define df_live (df->problems_by_index[DF_LIVE])
883 #define df_chain (df->problems_by_index[DF_CHAIN])
884 #define df_byte_lr (df->problems_by_index[DF_BYTE_LR])
885 #define df_note (df->problems_by_index[DF_NOTE])
886 #define df_md (df->problems_by_index[DF_MD])
887
888 /* This symbol turns on checking that each modification of the cfg has
889 been identified to the appropriate df routines. It is not part of
890 verification per se because the check that the final solution has
891 not changed covers this. However, if the solution is not being
892 properly recomputed because the cfg is being modified, adding in
893 calls to df_check_cfg_clean can be used to find the source of that
894 kind of problem. */
895 #if 0
896 #define DF_DEBUG_CFG
897 #endif
898
899
900 /* Functions defined in df-core.c. */
901
902 extern void df_add_problem (struct df_problem *);
903 extern int df_set_flags (int);
904 extern int df_clear_flags (int);
905 extern void df_set_blocks (bitmap);
906 extern void df_remove_problem (struct dataflow *);
907 extern void df_finish_pass (bool);
908 extern void df_analyze_problem (struct dataflow *, bitmap, int *, int);
909 extern void df_analyze (void);
910 extern int df_get_n_blocks (enum df_flow_dir);
911 extern int *df_get_postorder (enum df_flow_dir);
912 extern void df_simple_dataflow (enum df_flow_dir, df_init_function,
913 df_confluence_function_0, df_confluence_function_n,
914 df_transfer_function, bitmap, int *, int);
915 extern void df_mark_solutions_dirty (void);
916 extern bool df_get_bb_dirty (basic_block);
917 extern void df_set_bb_dirty (basic_block);
918 extern void df_set_bb_dirty_nonlr (basic_block);
919 extern void df_compact_blocks (void);
920 extern void df_bb_replace (int, basic_block);
921 extern void df_bb_delete (int);
922 extern void df_verify (void);
923 #ifdef DF_DEBUG_CFG
924 extern void df_check_cfg_clean (void);
925 #endif
926 extern df_ref df_bb_regno_first_def_find (basic_block, unsigned int);
927 extern df_ref df_bb_regno_last_def_find (basic_block, unsigned int);
928 extern df_ref df_find_def (rtx, rtx);
929 extern bool df_reg_defined (rtx, rtx);
930 extern df_ref df_find_use (rtx, rtx);
931 extern bool df_reg_used (rtx, rtx);
932 extern void df_worklist_dataflow (struct dataflow *,bitmap, int *, int);
933 extern void df_print_regset (FILE *file, bitmap r);
934 extern void df_print_byte_regset (FILE *file, bitmap r);
935 extern void df_dump (FILE *);
936 extern void df_dump_region (FILE *);
937 extern void df_dump_start (FILE *);
938 extern void df_dump_top (basic_block, FILE *);
939 extern void df_dump_bottom (basic_block, FILE *);
940 extern void df_refs_chain_dump (df_ref *, bool, FILE *);
941 extern void df_regs_chain_dump (df_ref, FILE *);
942 extern void df_insn_debug (rtx, bool, FILE *);
943 extern void df_insn_debug_regno (rtx, FILE *);
944 extern void df_regno_debug (unsigned int, FILE *);
945 extern void df_ref_debug (df_ref, FILE *);
946 extern void debug_df_insn (rtx);
947 extern void debug_df_regno (unsigned int);
948 extern void debug_df_reg (rtx);
949 extern void debug_df_defno (unsigned int);
950 extern void debug_df_useno (unsigned int);
951 extern void debug_df_ref (df_ref);
952 extern void debug_df_chain (struct df_link *);
953
954 /* Functions defined in df-problems.c. */
955
956 extern struct df_link *df_chain_create (df_ref, df_ref);
957 extern void df_chain_unlink (df_ref);
958 extern void df_chain_copy (df_ref, struct df_link *);
959 extern bitmap df_get_live_in (basic_block);
960 extern bitmap df_get_live_out (basic_block);
961 extern void df_grow_bb_info (struct dataflow *);
962 extern void df_chain_dump (struct df_link *, FILE *);
963 extern void df_print_bb_index (basic_block bb, FILE *file);
964 extern void df_rd_add_problem (void);
965 extern void df_rd_simulate_artificial_defs_at_top (basic_block, bitmap);
966 extern void df_rd_simulate_one_insn (basic_block, rtx, bitmap);
967 extern void df_lr_add_problem (void);
968 extern void df_lr_verify_transfer_functions (void);
969 extern void df_live_verify_transfer_functions (void);
970 extern void df_live_add_problem (void);
971 extern void df_live_set_all_dirty (void);
972 extern void df_chain_add_problem (unsigned int);
973 extern void df_byte_lr_add_problem (void);
974 extern int df_byte_lr_get_regno_start (unsigned int);
975 extern int df_byte_lr_get_regno_len (unsigned int);
976 extern void df_byte_lr_simulate_defs (rtx, bitmap);
977 extern void df_byte_lr_simulate_uses (rtx, bitmap);
978 extern void df_byte_lr_simulate_artificial_refs_at_top (basic_block, bitmap);
979 extern void df_byte_lr_simulate_artificial_refs_at_end (basic_block, bitmap);
980 extern void df_note_add_problem (void);
981 extern void df_md_add_problem (void);
982 extern void df_md_simulate_artificial_defs_at_top (basic_block, bitmap);
983 extern void df_md_simulate_one_insn (basic_block, rtx, bitmap);
984 extern void df_simulate_find_noclobber_defs (rtx, bitmap);
985 extern void df_simulate_find_defs (rtx, bitmap);
986 extern void df_simulate_defs (rtx, bitmap);
987 extern void df_simulate_uses (rtx, bitmap);
988 extern void df_simulate_initialize_backwards (basic_block, bitmap);
989 extern void df_simulate_one_insn_backwards (basic_block, rtx, bitmap);
990 extern void df_simulate_finalize_backwards (basic_block, bitmap);
991 extern void df_simulate_initialize_forwards (basic_block, bitmap);
992 extern void df_simulate_one_insn_forwards (basic_block, rtx, bitmap);
993
994 /* Functions defined in df-scan.c. */
995
996 extern void df_scan_alloc (bitmap);
997 extern void df_scan_add_problem (void);
998 extern void df_grow_reg_info (void);
999 extern void df_grow_insn_info (void);
1000 extern void df_scan_blocks (void);
1001 extern df_ref df_ref_create (rtx, rtx *, rtx,basic_block,
1002 enum df_ref_type, int ref_flags,
1003 int, int, enum machine_mode);
1004 extern void df_ref_remove (df_ref);
1005 extern struct df_insn_info * df_insn_create_insn_record (rtx);
1006 extern void df_insn_delete (basic_block, unsigned int);
1007 extern void df_bb_refs_record (int, bool);
1008 extern bool df_insn_rescan (rtx);
1009 extern bool df_insn_rescan_debug_internal (rtx);
1010 extern void df_insn_rescan_all (void);
1011 extern void df_process_deferred_rescans (void);
1012 extern void df_recompute_luids (basic_block);
1013 extern void df_insn_change_bb (rtx, basic_block);
1014 extern void df_maybe_reorganize_use_refs (enum df_ref_order);
1015 extern void df_maybe_reorganize_def_refs (enum df_ref_order);
1016 extern void df_ref_change_reg_with_loc (int, int, rtx);
1017 extern void df_notes_rescan (rtx);
1018 extern void df_hard_reg_init (void);
1019 extern void df_update_entry_block_defs (void);
1020 extern void df_update_exit_block_uses (void);
1021 extern void df_update_entry_exit_and_calls (void);
1022 extern bool df_hard_reg_used_p (unsigned int);
1023 extern unsigned int df_hard_reg_used_count (unsigned int);
1024 extern bool df_regs_ever_live_p (unsigned int);
1025 extern void df_set_regs_ever_live (unsigned int, bool);
1026 extern void df_compute_regs_ever_live (bool);
1027 extern bool df_read_modify_subreg_p (rtx);
1028 extern void df_scan_verify (void);
1029
1030 /* Functions defined in df-byte-scan.c. */
1031 extern bool df_compute_accessed_bytes (df_ref, enum df_mm,
1032 unsigned int *, unsigned int *);
1033
1034
1035 /* Get basic block info. */
1036
1037 static inline struct df_scan_bb_info *
1038 df_scan_get_bb_info (unsigned int index)
1039 {
1040 if (index < df_scan->block_info_size)
1041 return &((struct df_scan_bb_info *) df_scan->block_info)[index];
1042 else
1043 return NULL;
1044 }
1045
1046 static inline struct df_rd_bb_info *
1047 df_rd_get_bb_info (unsigned int index)
1048 {
1049 if (index < df_rd->block_info_size)
1050 return &((struct df_rd_bb_info *) df_rd->block_info)[index];
1051 else
1052 return NULL;
1053 }
1054
1055 static inline struct df_lr_bb_info *
1056 df_lr_get_bb_info (unsigned int index)
1057 {
1058 if (index < df_lr->block_info_size)
1059 return &((struct df_lr_bb_info *) df_lr->block_info)[index];
1060 else
1061 return NULL;
1062 }
1063
1064 static inline struct df_md_bb_info *
1065 df_md_get_bb_info (unsigned int index)
1066 {
1067 if (index < df_md->block_info_size)
1068 return &((struct df_md_bb_info *) df_md->block_info)[index];
1069 else
1070 return NULL;
1071 }
1072
1073 static inline struct df_live_bb_info *
1074 df_live_get_bb_info (unsigned int index)
1075 {
1076 if (index < df_live->block_info_size)
1077 return &((struct df_live_bb_info *) df_live->block_info)[index];
1078 else
1079 return NULL;
1080 }
1081
1082 static inline struct df_byte_lr_bb_info *
1083 df_byte_lr_get_bb_info (unsigned int index)
1084 {
1085 if (index < df_byte_lr->block_info_size)
1086 return &((struct df_byte_lr_bb_info *) df_byte_lr->block_info)[index];
1087 else
1088 return NULL;
1089 }
1090
1091 /* Get the artificial defs for a basic block. */
1092
1093 static inline df_ref *
1094 df_get_artificial_defs (unsigned int bb_index)
1095 {
1096 return df_scan_get_bb_info (bb_index)->artificial_defs;
1097 }
1098
1099
1100 /* Get the artificial uses for a basic block. */
1101
1102 static inline df_ref *
1103 df_get_artificial_uses (unsigned int bb_index)
1104 {
1105 return df_scan_get_bb_info (bb_index)->artificial_uses;
1106 }
1107
1108
1109 /* web */
1110
1111 /* This entry is allocated for each reference in the insn stream. */
1112 struct web_entry
1113 {
1114 /* Pointer to the parent in the union/find tree. */
1115 struct web_entry *pred;
1116 /* Newly assigned register to the entry. Set only for roots. */
1117 rtx reg;
1118 void* extra_info;
1119 };
1120
1121 extern struct web_entry *unionfind_root (struct web_entry *);
1122 extern bool unionfind_union (struct web_entry *, struct web_entry *);
1123 extern void union_defs (df_ref, struct web_entry *,
1124 unsigned int *used, struct web_entry *,
1125 bool (*fun) (struct web_entry *, struct web_entry *));
1126
1127 #endif /* GCC_DF_H */