OSDN Git Service

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