1 /* Form lists of pseudo register references for autoinc optimization
2 for GNU compiler. This is part of flow optimization.
3 Copyright (C) 1999-2014 Free Software Foundation, Inc.
4 Originally contributed by Michael P. Hayes
5 (m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
6 Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
7 and Kenneth Zadeck (zadeck@naturalbridge.com).
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
31 #include "basic-block.h"
32 #include "alloc-pool.h"
42 /* Data flow problems. All problems must have a unique id here. */
44 /* Scanning is not really a dataflow problem, but it is useful to have
45 the basic block functions in the vector so that things get done in
46 a uniform manner. The last four problems can be added or deleted
47 at any time are always defined (though LIVE is always there at -O2
48 or higher); the others are always there. */
50 #define DF_LR 1 /* Live Registers backward. */
51 #define DF_LIVE 2 /* Live Registers & Uninitialized Registers */
52 #define DF_RD 3 /* Reaching Defs. */
53 #define DF_CHAIN 4 /* Def-Use and/or Use-Def Chains. */
54 #define DF_WORD_LR 5 /* Subreg tracking lr. */
55 #define DF_NOTE 6 /* REG_DEAD and REG_UNUSED notes. */
56 #define DF_MD 7 /* Multiple Definitions. */
58 #define DF_LAST_PROBLEM_PLUS1 (DF_MD + 1)
60 /* Dataflow direction. */
68 /* Descriminator for the various df_ref types. */
69 enum df_ref_class
{DF_REF_BASE
, DF_REF_ARTIFICIAL
, DF_REF_REGULAR
};
71 /* The first of these us a set of a registers. The remaining three
72 are all uses of a register (the mem_load and mem_store relate to
73 how the register as an addressing operand). */
74 enum df_ref_type
{DF_REF_REG_DEF
, DF_REF_REG_USE
,
75 DF_REF_REG_MEM_LOAD
, DF_REF_REG_MEM_STORE
};
79 /* This flag is set if this ref occurs inside of a conditional
80 execution instruction. */
81 DF_REF_CONDITIONAL
= 1 << 0,
83 /* If this flag is set for an artificial use or def, that ref
84 logically happens at the top of the block. If it is not set
85 for an artificial use or def, that ref logically happens at the
86 bottom of the block. This is never set for regular refs. */
87 DF_REF_AT_TOP
= 1 << 1,
89 /* This flag is set if the use is inside a REG_EQUAL or REG_EQUIV
91 DF_REF_IN_NOTE
= 1 << 2,
93 /* This bit is true if this ref can make regs_ever_live true for
95 DF_HARD_REG_LIVE
= 1 << 3,
98 /* This flag is set if this ref is a partial use or def of the
99 associated register. */
100 DF_REF_PARTIAL
= 1 << 4,
102 /* Read-modify-write refs generate both a use and a def and
103 these are marked with this flag to show that they are not
105 DF_REF_READ_WRITE
= 1 << 5,
107 /* This flag is set if this ref, generally a def, may clobber the
108 referenced register. This is generally only set for hard
109 registers that cross a call site. With better information
110 about calls, some of these could be changed in the future to
111 DF_REF_MUST_CLOBBER. */
112 DF_REF_MAY_CLOBBER
= 1 << 6,
114 /* This flag is set if this ref, generally a def, is a real
115 clobber. This is not currently set for registers live across a
116 call because that clobbering may or may not happen.
118 Most of the uses of this are with sets that have a
119 GET_CODE(..)==CLOBBER. Note that this is set even if the
120 clobber is to a subreg. So in order to tell if the clobber
121 wipes out the entire register, it is necessary to also check
122 the DF_REF_PARTIAL flag. */
123 DF_REF_MUST_CLOBBER
= 1 << 7,
126 /* If the ref has one of the following two flags set, then the
127 struct df_ref can be cast to struct df_ref_extract to access
128 the width and offset fields. */
130 /* This flag is set if the ref contains a SIGN_EXTRACT. */
131 DF_REF_SIGN_EXTRACT
= 1 << 8,
133 /* This flag is set if the ref contains a ZERO_EXTRACT. */
134 DF_REF_ZERO_EXTRACT
= 1 << 9,
136 /* This flag is set if the ref contains a STRICT_LOW_PART. */
137 DF_REF_STRICT_LOW_PART
= 1 << 10,
139 /* This flag is set if the ref contains a SUBREG. */
140 DF_REF_SUBREG
= 1 << 11,
143 /* This bit is true if this ref is part of a multiword hardreg. */
144 DF_REF_MW_HARDREG
= 1 << 12,
146 /* This flag is set if this ref is a usage of the stack pointer by
148 DF_REF_CALL_STACK_USAGE
= 1 << 13,
150 /* This flag is used for verification of existing refs. */
151 DF_REF_REG_MARKER
= 1 << 14,
153 /* This flag is set if this ref is inside a pre/post modify. */
154 DF_REF_PRE_POST_MODIFY
= 1 << 15
158 /* The possible ordering of refs within the df_ref_info. */
161 /* There is not table. */
162 DF_REF_ORDER_NO_TABLE
,
164 /* There is a table of refs but it is not (or no longer) organized
165 by one of the following methods. */
166 DF_REF_ORDER_UNORDERED
,
167 DF_REF_ORDER_UNORDERED_WITH_NOTES
,
169 /* Organize the table by reg order, all of the refs with regno 0
170 followed by all of the refs with regno 1 ... . Within all of
171 the regs for a particular regno, the refs are unordered. */
174 /* For uses, the refs within eq notes may be added for
175 DF_REF_ORDER_BY_REG. */
176 DF_REF_ORDER_BY_REG_WITH_NOTES
,
178 /* Organize the refs in insn order. The insns are ordered within a
179 block, and the blocks are ordered by FOR_ALL_BB_FN. */
180 DF_REF_ORDER_BY_INSN
,
182 /* For uses, the refs within eq notes may be added for
183 DF_REF_ORDER_BY_INSN. */
184 DF_REF_ORDER_BY_INSN_WITH_NOTES
187 /* Function prototypes added to df_problem instance. */
189 /* Allocate the problem specific data. */
190 typedef void (*df_alloc_function
) (bitmap
);
192 /* This function is called if the problem has global data that needs
193 to be cleared when ever the set of blocks changes. The bitmap
194 contains the set of blocks that may require special attention.
195 This call is only made if some of the blocks are going to change.
196 If everything is to be deleted, the wholesale deletion mechanisms
198 typedef void (*df_reset_function
) (bitmap
);
200 /* Free the basic block info. Called from the block reordering code
201 to get rid of the blocks that have been squished down. */
202 typedef void (*df_free_bb_function
) (basic_block
, void *);
204 /* Local compute function. */
205 typedef void (*df_local_compute_function
) (bitmap
);
207 /* Init the solution specific data. */
208 typedef void (*df_init_function
) (bitmap
);
210 /* Iterative dataflow function. */
211 typedef void (*df_dataflow_function
) (struct dataflow
*, bitmap
, int *, int);
213 /* Confluence operator for blocks with 0 out (or in) edges. */
214 typedef void (*df_confluence_function_0
) (basic_block
);
216 /* Confluence operator for blocks with 1 or more out (or in) edges.
217 Return true if BB input data has changed. */
218 typedef bool (*df_confluence_function_n
) (edge
);
220 /* Transfer function for blocks.
221 Return true if BB output data has changed. */
222 typedef bool (*df_transfer_function
) (int);
224 /* Function to massage the information after the problem solving. */
225 typedef void (*df_finalizer_function
) (bitmap
);
227 /* Function to free all of the problem specific datastructures. */
228 typedef void (*df_free_function
) (void);
230 /* Function to remove this problem from the stack of dataflow problems
231 without effecting the other problems in the stack except for those
232 that depend on this problem. */
233 typedef void (*df_remove_problem_function
) (void);
235 /* Function to dump basic block independent results to FILE. */
236 typedef void (*df_dump_problem_function
) (FILE *);
238 /* Function to dump top or bottom of basic block results to FILE. */
239 typedef void (*df_dump_bb_problem_function
) (basic_block
, FILE *);
241 /* Function to dump before or after an insn to FILE. */
242 typedef void (*df_dump_insn_problem_function
) (const_rtx
, FILE *);
244 /* Function to dump top or bottom of basic block results to FILE. */
245 typedef void (*df_verify_solution_start
) (void);
247 /* Function to dump top or bottom of basic block results to FILE. */
248 typedef void (*df_verify_solution_end
) (void);
250 /* The static description of a dataflow problem to solve. See above
251 typedefs for doc for the function fields. */
254 /* The unique id of the problem. This is used it index into
255 df->defined_problems to make accessing the problem data easy. */
257 enum df_flow_dir dir
; /* Dataflow direction. */
258 df_alloc_function alloc_fun
;
259 df_reset_function reset_fun
;
260 df_free_bb_function free_bb_fun
;
261 df_local_compute_function local_compute_fun
;
262 df_init_function init_fun
;
263 df_dataflow_function dataflow_fun
;
264 df_confluence_function_0 con_fun_0
;
265 df_confluence_function_n con_fun_n
;
266 df_transfer_function trans_fun
;
267 df_finalizer_function finalize_fun
;
268 df_free_function free_fun
;
269 df_remove_problem_function remove_problem_fun
;
270 df_dump_problem_function dump_start_fun
;
271 df_dump_bb_problem_function dump_top_fun
;
272 df_dump_bb_problem_function dump_bottom_fun
;
273 df_dump_insn_problem_function dump_insn_top_fun
;
274 df_dump_insn_problem_function dump_insn_bottom_fun
;
275 df_verify_solution_start verify_start_fun
;
276 df_verify_solution_end verify_end_fun
;
277 struct df_problem
*dependent_problem
;
278 unsigned int block_info_elt_size
;
280 /* The timevar id associated with this pass. */
283 /* True if the df_set_blocks should null out the basic block info if
284 this block drops out of df->blocks_to_analyze. */
285 bool free_blocks_on_set_blocks
;
289 /* The specific instance of the problem to solve. */
292 struct df_problem
*problem
; /* The problem to be solved. */
294 /* Array indexed by bb->index, that contains basic block problem and
295 solution specific information. */
297 unsigned int block_info_size
;
299 /* The pool to allocate the block_info from. */
300 alloc_pool block_pool
;
302 /* The lr and live problems have their transfer functions recomputed
303 only if necessary. This is possible for them because, the
304 problems are kept active for the entire backend and their
305 transfer functions are indexed by the REGNO. These are not
306 defined for any other problem. */
307 bitmap out_of_date_transfer_functions
;
309 /* Other problem specific data that is not on a per basic block
310 basis. The structure is generally defined privately for the
311 problem. The exception being the scanning problem where it is
315 /* Local flags for some of the problems. */
316 unsigned int local_flags
;
318 /* True if this problem of this instance has been initialized. This
319 is used by the dumpers to keep garbage out of the dumps if, for
320 debugging a dump is produced before the first call to
321 df_analyze after a new problem is added. */
324 /* True if the something has changed which invalidates the dataflow
325 solutions. Note that this bit is always true for all problems except
327 bool solutions_dirty
;
329 /* If true, this pass is deleted by df_finish_pass. This is never
330 true for DF_SCAN and DF_LR. It is true for DF_LIVE if optimize >
331 1. It is always true for the other problems. */
336 /* The set of multiword hardregs used as operands to this
337 instruction. These are factored into individual uses and defs but
338 the aggregate is still needed to service the REG_DEAD and
342 df_mw_hardreg
*next
; /* Next entry for this instruction. */
343 rtx mw_reg
; /* The multiword hardreg. */
344 /* These two bitfields are intentionally oversized, in the hope that
345 accesses to 16-bit fields will usually be quicker. */
346 ENUM_BITFIELD(df_ref_type
) type
: 16;
347 /* Used to see if the ref is read or write. */
348 int flags
: 16; /* Various df_ref_flags. */
349 unsigned int start_regno
; /* First word of the multi word subreg. */
350 unsigned int end_regno
; /* Last word of the multi word subreg. */
351 unsigned int mw_order
; /* Same as df_ref.ref_order. */
355 /* Define a register reference structure. One of these is allocated
356 for every register reference (use or def). Note some register
357 references (e.g., post_inc, subreg) generate both a def and a use. */
360 /* These three bitfields are intentionally oversized, in the hope that
361 accesses to 8 and 16-bit fields will usually be quicker. */
362 ENUM_BITFIELD(df_ref_class
) cl
: 8;
364 ENUM_BITFIELD(df_ref_type
) type
: 8;
366 int flags
: 16; /* Various df_ref_flags. */
367 unsigned int regno
; /* The register number referenced. */
368 rtx reg
; /* The register referenced. */
369 union df_ref_d
*next_loc
; /* Next ref for same insn or bb. */
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 through 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. */
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
;
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
393 struct df_base_ref base
;
395 /* Artificial refs do not have an insn, so to get the basic block,
396 it must be explicitly here. */
401 struct df_regular_ref
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. */
411 /* Union of the different kinds of defs/uses placeholders. */
414 struct df_base_ref base
;
415 struct df_regular_ref regular_ref
;
416 struct df_artificial_ref artificial_ref
;
418 typedef union df_ref_d
*df_ref
;
421 /* One of these structures is allocated for every insn. */
424 rtx insn
; /* The insn this info comes from. */
425 df_ref defs
; /* Head of insn-def chain. */
426 df_ref uses
; /* Head of insn-use chain. */
427 /* Head of insn-use chain for uses in REG_EQUAL/EQUIV notes. */
429 struct df_mw_hardreg
*mw_hardregs
;
430 /* The logical uid of the insn in the basic block. This is valid
431 after any call to df_analyze but may rot after insns are added,
436 /* These links are used for ref-ref chains. Currently only DEF-USE and
437 USE-DEF chains can be built by DF. */
441 struct df_link
*next
;
447 /* Flags that control the building of chains. */
448 DF_DU_CHAIN
= 1, /* Build DU chains. */
449 DF_UD_CHAIN
= 2 /* Build UD chains. */
452 enum df_changeable_flags
454 /* Scanning flags. */
455 /* Flag to control the running of dce as a side effect of building LR. */
456 DF_LR_RUN_DCE
= 1 << 0, /* Run DCE. */
457 DF_NO_HARD_REGS
= 1 << 1, /* Skip hard registers in RD and CHAIN Building. */
459 DF_EQ_NOTES
= 1 << 2, /* Build chains with uses present in EQUIV/EQUAL notes. */
460 DF_NO_REGS_EVER_LIVE
= 1 << 3, /* Do not compute the regs_ever_live. */
462 /* Cause df_insn_rescan df_notes_rescan and df_insn_delete, to
463 return immediately. This is used by passes that know how to update
464 the scanning them selves. */
465 DF_NO_INSN_RESCAN
= 1 << 4,
467 /* Cause df_insn_rescan df_notes_rescan and df_insn_delete, to
468 return after marking the insn for later processing. This allows all
469 rescans to be batched. */
470 DF_DEFER_INSN_RESCAN
= 1 << 5,
472 /* Compute the reaching defs problem as "live and reaching defs" (LR&RD).
473 A DEF is reaching and live at insn I if DEF reaches I and REGNO(DEF)
474 is in LR_IN of the basic block containing I. */
475 DF_RD_PRUNE_DEAD_DEFS
= 1 << 6,
477 DF_VERIFY_SCHEDULED
= 1 << 7
480 /* Two of these structures are inline in df, one for the uses and one
481 for the defs. This structure is only contains the refs within the
482 boundary of the df_set_blocks if that has been defined. */
485 df_ref
*refs
; /* Ref table, indexed by id. */
486 unsigned int *begin
; /* First ref_index for this pseudo. */
487 unsigned int *count
; /* Count of refs for this pseudo. */
488 unsigned int refs_size
; /* Size of currently allocated refs table. */
490 /* Table_size is the number of elements in the refs table. This
491 will also be the width of the bitvectors in the rd and ru
492 problems. Total_size is the number of refs. These will be the
493 same if the focus has not been reduced by df_set_blocks. If the
494 focus has been reduced, table_size will be smaller since it only
495 contains the refs in the set blocks. */
496 unsigned int table_size
;
497 unsigned int total_size
;
499 enum df_ref_order ref_order
;
502 /* Three of these structures are allocated for every pseudo reg. One
503 for the uses, one for the eq_uses and one for the defs. */
506 /* Head of chain for refs of that type and regno. */
508 /* Number of refs in the chain. */
513 /*----------------------------------------------------------------------------
514 Problem data for the scanning dataflow problem. Unlike the other
515 dataflow problems, the problem data for scanning is fully exposed and
516 used by owners of the problem.
517 ----------------------------------------------------------------------------*/
522 /* The set of problems to be solved is stored in two arrays. In
523 PROBLEMS_IN_ORDER, the problems are stored in the order that they
524 are solved. This is an internally dense array that may have
525 nulls at the end of it. In PROBLEMS_BY_INDEX, the problem is
526 stored by the value in df_problem.id. These are used to access
527 the problem local data without having to search the first
530 struct dataflow
*problems_in_order
[DF_LAST_PROBLEM_PLUS1
];
531 struct dataflow
*problems_by_index
[DF_LAST_PROBLEM_PLUS1
];
533 /* If not NULL, this subset of blocks of the program to be
534 considered for analysis. At certain times, this will contain all
535 the blocks in the function so it cannot be used as an indicator
536 of if we are analyzing a subset. See analyze_subset. */
537 bitmap blocks_to_analyze
;
539 /* The following information is really the problem data for the
540 scanning instance but it is used too often by the other problems
541 to keep getting it from there. */
542 struct df_ref_info def_info
; /* Def info. */
543 struct df_ref_info use_info
; /* Use info. */
545 /* The following three arrays are allocated in parallel. They contain
546 the sets of refs of each type for each reg. */
547 struct df_reg_info
**def_regs
; /* Def reg info. */
548 struct df_reg_info
**use_regs
; /* Eq_use reg info. */
549 struct df_reg_info
**eq_use_regs
; /* Eq_use info. */
550 unsigned int regs_size
; /* Size of currently allocated regs table. */
551 unsigned int regs_inited
; /* Number of regs with reg_infos allocated. */
554 struct df_insn_info
**insns
; /* Insn table, indexed by insn UID. */
555 unsigned int insns_size
; /* Size of insn table. */
557 int num_problems_defined
;
559 bitmap_head hardware_regs_used
; /* The set of hardware registers used. */
560 /* The set of hard regs that are in the artificial uses at the end
561 of a regular basic block. */
562 bitmap_head regular_block_artificial_uses
;
563 /* The set of hard regs that are in the artificial uses at the end
564 of a basic block that has an EH pred. */
565 bitmap_head eh_block_artificial_uses
;
566 /* The set of hardware registers live on entry to the function. */
567 bitmap entry_block_defs
;
568 bitmap exit_block_uses
; /* The set of hardware registers used in exit block. */
570 /* Insns to delete, rescan or reprocess the notes at next
571 df_rescan_all or df_process_deferred_rescans. */
572 bitmap_head insns_to_delete
;
573 bitmap_head insns_to_rescan
;
574 bitmap_head insns_to_notes_rescan
;
575 int *postorder
; /* The current set of basic blocks
576 in reverse postorder. */
577 int *postorder_inverted
; /* The current set of basic blocks
578 in reverse postorder of inverted CFG. */
579 int n_blocks
; /* The number of blocks in reverse postorder. */
580 int n_blocks_inverted
; /* The number of blocks
581 in reverse postorder of inverted CFG. */
583 /* An array [FIRST_PSEUDO_REGISTER], indexed by regno, of the number
584 of refs that qualify as being real hard regs uses. Artificial
585 uses and defs as well as refs in eq notes are ignored. If the
586 ref is a def, it cannot be a MAY_CLOBBER def. If the ref is a
587 use, it cannot be the emim_reg_set or be the frame or arg pointer
588 register. Uses in debug insns are ignored.
590 IT IS NOT ACCEPTABLE TO MANUALLY CHANGE THIS ARRAY. This array
591 always reflects the actual number of refs in the insn stream that
592 satisfy the above criteria. */
593 unsigned int *hard_regs_live_count
;
595 /* This counter provides a way to totally order refs without using
596 addresses. It is incremented whenever a ref is created. */
597 unsigned int ref_order
;
599 /* Problem specific control information. This is a combination of
600 enum df_changeable_flags values. */
601 int changeable_flags
: 8;
603 /* If this is true, then only a subset of the blocks of the program
604 is considered to compute the solutions of dataflow problems. */
607 /* True if someone added or deleted something from regs_ever_live so
608 that the entry and exit blocks need be reprocessed. */
609 bool redo_entry_and_exit
;
612 #define DF_SCAN_BB_INFO(BB) (df_scan_get_bb_info ((BB)->index))
613 #define DF_RD_BB_INFO(BB) (df_rd_get_bb_info ((BB)->index))
614 #define DF_LR_BB_INFO(BB) (df_lr_get_bb_info ((BB)->index))
615 #define DF_LIVE_BB_INFO(BB) (df_live_get_bb_info ((BB)->index))
616 #define DF_WORD_LR_BB_INFO(BB) (df_word_lr_get_bb_info ((BB)->index))
617 #define DF_MD_BB_INFO(BB) (df_md_get_bb_info ((BB)->index))
619 /* Most transformations that wish to use live register analysis will
620 use these macros. This info is the and of the lr and live sets. */
621 #define DF_LIVE_IN(BB) (&DF_LIVE_BB_INFO (BB)->in)
622 #define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO (BB)->out)
624 /* These macros are used by passes that are not tolerant of
625 uninitialized variables. This intolerance should eventually
627 #define DF_LR_IN(BB) (&DF_LR_BB_INFO (BB)->in)
628 #define DF_LR_OUT(BB) (&DF_LR_BB_INFO (BB)->out)
630 /* These macros are used by passes that are not tolerant of
631 uninitialized variables. This intolerance should eventually
633 #define DF_WORD_LR_IN(BB) (&DF_WORD_LR_BB_INFO (BB)->in)
634 #define DF_WORD_LR_OUT(BB) (&DF_WORD_LR_BB_INFO (BB)->out)
636 /* Macros to access the elements within the ref structure. */
639 #define DF_REF_REAL_REG(REF) (GET_CODE ((REF)->base.reg) == SUBREG \
640 ? SUBREG_REG ((REF)->base.reg) : ((REF)->base.reg))
641 #define DF_REF_REGNO(REF) ((REF)->base.regno)
642 #define DF_REF_REAL_LOC(REF) (GET_CODE (*((REF)->regular_ref.loc)) == SUBREG \
643 ? &SUBREG_REG (*((REF)->regular_ref.loc)) : ((REF)->regular_ref.loc))
644 #define DF_REF_REG(REF) ((REF)->base.reg)
645 #define DF_REF_LOC(REF) (DF_REF_CLASS (REF) == DF_REF_REGULAR ? \
646 (REF)->regular_ref.loc : NULL)
647 #define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL (REF) \
648 ? (REF)->artificial_ref.bb \
649 : BLOCK_FOR_INSN (DF_REF_INSN (REF)))
650 #define DF_REF_BBNO(REF) (DF_REF_BB (REF)->index)
651 #define DF_REF_INSN_INFO(REF) ((REF)->base.insn_info)
652 extern rtx_insn
*DF_REF_INSN (df_ref ref
);
653 #define DF_REF_INSN_UID(REF) (INSN_UID (DF_REF_INSN(REF)))
654 #define DF_REF_CLASS(REF) ((REF)->base.cl)
655 #define DF_REF_TYPE(REF) ((REF)->base.type)
656 #define DF_REF_CHAIN(REF) ((REF)->base.chain)
657 #define DF_REF_ID(REF) ((REF)->base.id)
658 #define DF_REF_FLAGS(REF) ((REF)->base.flags)
659 #define DF_REF_FLAGS_IS_SET(REF, v) ((DF_REF_FLAGS (REF) & (v)) != 0)
660 #define DF_REF_FLAGS_SET(REF, v) (DF_REF_FLAGS (REF) |= (v))
661 #define DF_REF_FLAGS_CLEAR(REF, v) (DF_REF_FLAGS (REF) &= ~(v))
662 #define DF_REF_ORDER(REF) ((REF)->base.ref_order)
663 /* If DF_REF_IS_ARTIFICIAL () is true, this is not a real
664 definition/use, but an artificial one created to model always live
665 registers, eh uses, etc. */
666 #define DF_REF_IS_ARTIFICIAL(REF) (DF_REF_CLASS (REF) == DF_REF_ARTIFICIAL)
667 #define DF_REF_REG_MARK(REF) (DF_REF_FLAGS_SET ((REF),DF_REF_REG_MARKER))
668 #define DF_REF_REG_UNMARK(REF) (DF_REF_FLAGS_CLEAR ((REF),DF_REF_REG_MARKER))
669 #define DF_REF_IS_REG_MARKED(REF) (DF_REF_FLAGS_IS_SET ((REF),DF_REF_REG_MARKER))
670 #define DF_REF_NEXT_LOC(REF) ((REF)->base.next_loc)
671 #define DF_REF_NEXT_REG(REF) ((REF)->base.next_reg)
672 #define DF_REF_PREV_REG(REF) ((REF)->base.prev_reg)
673 /* The following two macros may only be applied if one of
674 DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT is true. */
675 #define DF_REF_EXTRACT_WIDTH(REF) ((REF)->extract_ref.width)
676 #define DF_REF_EXTRACT_OFFSET(REF) ((REF)->extract_ref.offset)
677 #define DF_REF_EXTRACT_MODE(REF) ((REF)->extract_ref.mode)
679 /* Macros to determine the reference type. */
680 #define DF_REF_REG_DEF_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_DEF)
681 #define DF_REF_REG_USE_P(REF) (!DF_REF_REG_DEF_P (REF))
682 #define DF_REF_REG_MEM_STORE_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_MEM_STORE)
683 #define DF_REF_REG_MEM_LOAD_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_MEM_LOAD)
684 #define DF_REF_REG_MEM_P(REF) (DF_REF_REG_MEM_STORE_P (REF) \
685 || DF_REF_REG_MEM_LOAD_P (REF))
687 #define DF_MWS_REG_DEF_P(MREF) (DF_MWS_TYPE (MREF) == DF_REF_REG_DEF)
688 #define DF_MWS_REG_USE_P(MREF) (!DF_MWS_REG_DEF_P (MREF))
689 #define DF_MWS_NEXT(MREF) ((MREF)->next)
690 #define DF_MWS_TYPE(MREF) ((MREF)->type)
692 /* Macros to get the refs out of def_info or use_info refs table. If
693 the focus of the dataflow has been set to some subset of blocks
694 with df_set_blocks, these macros will only find the uses and defs
695 in that subset of blocks.
697 These macros should be used with care. The def macros are only
698 usable after a call to df_maybe_reorganize_def_refs and the use
699 macros are only usable after a call to
700 df_maybe_reorganize_use_refs. HOWEVER, BUILDING AND USING THESE
701 ARRAYS ARE A CACHE LOCALITY KILLER. */
703 #define DF_DEFS_TABLE_SIZE() (df->def_info.table_size)
704 #define DF_DEFS_GET(ID) (df->def_info.refs[(ID)])
705 #define DF_DEFS_SET(ID,VAL) (df->def_info.refs[(ID)]=(VAL))
706 #define DF_DEFS_COUNT(ID) (df->def_info.count[(ID)])
707 #define DF_DEFS_BEGIN(ID) (df->def_info.begin[(ID)])
708 #define DF_USES_TABLE_SIZE() (df->use_info.table_size)
709 #define DF_USES_GET(ID) (df->use_info.refs[(ID)])
710 #define DF_USES_SET(ID,VAL) (df->use_info.refs[(ID)]=(VAL))
711 #define DF_USES_COUNT(ID) (df->use_info.count[(ID)])
712 #define DF_USES_BEGIN(ID) (df->use_info.begin[(ID)])
714 /* Macros to access the register information from scan dataflow record. */
716 #define DF_REG_SIZE(DF) (df->regs_inited)
717 #define DF_REG_DEF_GET(REG) (df->def_regs[(REG)])
718 #define DF_REG_DEF_CHAIN(REG) (df->def_regs[(REG)]->reg_chain)
719 #define DF_REG_DEF_COUNT(REG) (df->def_regs[(REG)]->n_refs)
720 #define DF_REG_USE_GET(REG) (df->use_regs[(REG)])
721 #define DF_REG_USE_CHAIN(REG) (df->use_regs[(REG)]->reg_chain)
722 #define DF_REG_USE_COUNT(REG) (df->use_regs[(REG)]->n_refs)
723 #define DF_REG_EQ_USE_GET(REG) (df->eq_use_regs[(REG)])
724 #define DF_REG_EQ_USE_CHAIN(REG) (df->eq_use_regs[(REG)]->reg_chain)
725 #define DF_REG_EQ_USE_COUNT(REG) (df->eq_use_regs[(REG)]->n_refs)
727 /* Macros to access the elements within the reg_info structure table. */
729 #define DF_REGNO_FIRST_DEF(REGNUM) \
730 (DF_REG_DEF_GET(REGNUM) ? DF_REG_DEF_GET (REGNUM) : 0)
731 #define DF_REGNO_LAST_USE(REGNUM) \
732 (DF_REG_USE_GET(REGNUM) ? DF_REG_USE_GET (REGNUM) : 0)
734 /* Macros to access the elements within the insn_info structure table. */
736 #define DF_INSN_SIZE() ((df)->insns_size)
737 #define DF_INSN_INFO_GET(INSN) (df->insns[(INSN_UID (INSN))])
738 #define DF_INSN_INFO_SET(INSN,VAL) (df->insns[(INSN_UID (INSN))]=(VAL))
739 #define DF_INSN_INFO_LUID(II) ((II)->luid)
740 #define DF_INSN_INFO_DEFS(II) ((II)->defs)
741 #define DF_INSN_INFO_USES(II) ((II)->uses)
742 #define DF_INSN_INFO_EQ_USES(II) ((II)->eq_uses)
743 #define DF_INSN_INFO_MWS(II) ((II)->mw_hardregs)
745 #define DF_INSN_LUID(INSN) (DF_INSN_INFO_LUID (DF_INSN_INFO_GET (INSN)))
746 #define DF_INSN_DEFS(INSN) (DF_INSN_INFO_DEFS (DF_INSN_INFO_GET (INSN)))
747 #define DF_INSN_USES(INSN) (DF_INSN_INFO_USES (DF_INSN_INFO_GET (INSN)))
748 #define DF_INSN_EQ_USES(INSN) (DF_INSN_INFO_EQ_USES (DF_INSN_INFO_GET (INSN)))
750 #define DF_INSN_UID_GET(UID) (df->insns[(UID)])
751 #define DF_INSN_UID_SET(UID,VAL) (df->insns[(UID)]=(VAL))
752 #define DF_INSN_UID_SAFE_GET(UID) (((unsigned)(UID) < DF_INSN_SIZE ()) \
753 ? DF_INSN_UID_GET (UID) \
755 #define DF_INSN_UID_LUID(INSN) (DF_INSN_UID_GET (INSN)->luid)
756 #define DF_INSN_UID_DEFS(INSN) (DF_INSN_UID_GET (INSN)->defs)
757 #define DF_INSN_UID_USES(INSN) (DF_INSN_UID_GET (INSN)->uses)
758 #define DF_INSN_UID_EQ_USES(INSN) (DF_INSN_UID_GET (INSN)->eq_uses)
759 #define DF_INSN_UID_MWS(INSN) (DF_INSN_UID_GET (INSN)->mw_hardregs)
761 #define FOR_EACH_INSN_INFO_DEF(ITER, INSN) \
762 for (ITER = DF_INSN_INFO_DEFS (INSN); ITER; ITER = DF_REF_NEXT_LOC (ITER))
764 #define FOR_EACH_INSN_INFO_USE(ITER, INSN) \
765 for (ITER = DF_INSN_INFO_USES (INSN); ITER; ITER = DF_REF_NEXT_LOC (ITER))
767 #define FOR_EACH_INSN_INFO_EQ_USE(ITER, INSN) \
768 for (ITER = DF_INSN_INFO_EQ_USES (INSN); ITER; ITER = DF_REF_NEXT_LOC (ITER))
770 #define FOR_EACH_INSN_INFO_MW(ITER, INSN) \
771 for (ITER = DF_INSN_INFO_MWS (INSN); ITER; ITER = DF_MWS_NEXT (ITER))
773 #define FOR_EACH_INSN_DEF(ITER, INSN) \
774 FOR_EACH_INSN_INFO_DEF(ITER, DF_INSN_INFO_GET (INSN))
776 #define FOR_EACH_INSN_USE(ITER, INSN) \
777 FOR_EACH_INSN_INFO_USE(ITER, DF_INSN_INFO_GET (INSN))
779 #define FOR_EACH_INSN_EQ_USE(ITER, INSN) \
780 FOR_EACH_INSN_INFO_EQ_USE(ITER, DF_INSN_INFO_GET (INSN))
782 #define FOR_EACH_ARTIFICIAL_USE(ITER, BB_INDEX) \
783 for (ITER = df_get_artificial_uses (BB_INDEX); ITER; \
784 ITER = DF_REF_NEXT_LOC (ITER))
786 #define FOR_EACH_ARTIFICIAL_DEF(ITER, BB_INDEX) \
787 for (ITER = df_get_artificial_defs (BB_INDEX); ITER; \
788 ITER = DF_REF_NEXT_LOC (ITER))
790 /* An obstack for bitmap not related to specific dataflow problems.
791 This obstack should e.g. be used for bitmaps with a short life time
792 such as temporary bitmaps. This obstack is declared in df-core.c. */
794 extern bitmap_obstack df_bitmap_obstack
;
797 /* One of these structures is allocated for every basic block. */
798 struct df_scan_bb_info
800 /* The entry block has many artificial defs and these are at the
803 Blocks that are targets of exception edges may have some
804 artificial defs. These are logically located at the top of the
807 Blocks that are the targets of non-local goto's have the hard
808 frame pointer defined at the top of the block. */
809 df_ref artificial_defs
;
811 /* Blocks that are targets of exception edges may have some
812 artificial uses. These are logically at the top of the block.
814 Most blocks have artificial uses at the bottom of the block. */
815 df_ref artificial_uses
;
819 /* Reaching definitions. All bitmaps are indexed by the id field of
820 the ref except sparse_kill which is indexed by regno. For the
821 LR&RD problem, the kill set is not complete: It does not contain
822 DEFs killed because the set register has died in the LR set. */
825 /* Local sets to describe the basic blocks. */
827 bitmap_head sparse_kill
;
828 bitmap_head gen
; /* The set of defs generated in this block. */
830 /* The results of the dataflow problem. */
831 bitmap_head in
; /* At the top of the block. */
832 bitmap_head out
; /* At the bottom of the block. */
836 /* Multiple reaching definitions. All bitmaps are referenced by the
841 /* Local sets to describe the basic blocks. */
842 bitmap_head gen
; /* Partial/conditional definitions live at BB out. */
843 bitmap_head kill
; /* Other definitions that are live at BB out. */
844 bitmap_head init
; /* Definitions coming from dominance frontier edges. */
846 /* The results of the dataflow problem. */
847 bitmap_head in
; /* Just before the block itself. */
848 bitmap_head out
; /* At the bottom of the block. */
852 /* Live registers, a backwards dataflow problem. All bitmaps are
853 referenced by the register number. */
857 /* Local sets to describe the basic blocks. */
858 bitmap_head def
; /* The set of registers set in this block
859 - except artificial defs at the top. */
860 bitmap_head use
; /* The set of registers used in this block. */
862 /* The results of the dataflow problem. */
863 bitmap_head in
; /* Just before the block itself. */
864 bitmap_head out
; /* At the bottom of the block. */
868 /* Uninitialized registers. All bitmaps are referenced by the
869 register number. Anded results of the forwards and backward live
870 info. Note that the forwards live information is not available
872 struct df_live_bb_info
874 /* Local sets to describe the basic blocks. */
875 bitmap_head kill
; /* The set of registers unset in this block. Calls,
876 for instance, unset registers. */
877 bitmap_head gen
; /* The set of registers set in this block. */
879 /* The results of the dataflow problem. */
880 bitmap_head in
; /* At the top of the block. */
881 bitmap_head out
; /* At the bottom of the block. */
885 /* Live registers, a backwards dataflow problem. These bitmaps are
886 indexed by 2 * regno for each pseudo and have two entries for each
887 pseudo. Only pseudos that have a size of 2 * UNITS_PER_WORD are
888 meaningfully tracked. */
890 struct df_word_lr_bb_info
892 /* Local sets to describe the basic blocks. */
893 bitmap_head def
; /* The set of registers set in this block
894 - except artificial defs at the top. */
895 bitmap_head use
; /* The set of registers used in this block. */
897 /* The results of the dataflow problem. */
898 bitmap_head in
; /* Just before the block itself. */
899 bitmap_head out
; /* At the bottom of the block. */
903 /* This is used for debugging and for the dumpers to find the latest
904 instance so that the df info can be added to the dumps. This
905 should not be used by regular code. */
906 extern struct df_d
*df
;
907 #define df_scan (df->problems_by_index[DF_SCAN])
908 #define df_rd (df->problems_by_index[DF_RD])
909 #define df_lr (df->problems_by_index[DF_LR])
910 #define df_live (df->problems_by_index[DF_LIVE])
911 #define df_chain (df->problems_by_index[DF_CHAIN])
912 #define df_word_lr (df->problems_by_index[DF_WORD_LR])
913 #define df_note (df->problems_by_index[DF_NOTE])
914 #define df_md (df->problems_by_index[DF_MD])
916 /* This symbol turns on checking that each modification of the cfg has
917 been identified to the appropriate df routines. It is not part of
918 verification per se because the check that the final solution has
919 not changed covers this. However, if the solution is not being
920 properly recomputed because the cfg is being modified, adding in
921 calls to df_check_cfg_clean can be used to find the source of that
928 /* Functions defined in df-core.c. */
930 extern void df_add_problem (struct df_problem
*);
931 extern int df_set_flags (int);
932 extern int df_clear_flags (int);
933 extern void df_set_blocks (bitmap
);
934 extern void df_remove_problem (struct dataflow
*);
935 extern void df_finish_pass (bool);
936 extern void df_analyze_problem (struct dataflow
*, bitmap
, int *, int);
937 extern void df_analyze ();
938 extern void df_analyze_loop (struct loop
*);
939 extern int df_get_n_blocks (enum df_flow_dir
);
940 extern int *df_get_postorder (enum df_flow_dir
);
941 extern void df_simple_dataflow (enum df_flow_dir
, df_init_function
,
942 df_confluence_function_0
, df_confluence_function_n
,
943 df_transfer_function
, bitmap
, int *, int);
944 extern void df_mark_solutions_dirty (void);
945 extern bool df_get_bb_dirty (basic_block
);
946 extern void df_set_bb_dirty (basic_block
);
947 extern void df_compact_blocks (void);
948 extern void df_bb_replace (int, basic_block
);
949 extern void df_bb_delete (int);
950 extern void df_verify (void);
952 extern void df_check_cfg_clean (void);
954 extern df_ref
df_bb_regno_first_def_find (basic_block
, unsigned int);
955 extern df_ref
df_bb_regno_last_def_find (basic_block
, unsigned int);
956 extern df_ref
df_find_def (rtx
, rtx
);
957 extern bool df_reg_defined (rtx
, rtx
);
958 extern df_ref
df_find_use (rtx
, rtx
);
959 extern bool df_reg_used (rtx
, rtx
);
960 extern void df_worklist_dataflow (struct dataflow
*,bitmap
, int *, int);
961 extern void df_print_regset (FILE *file
, bitmap r
);
962 extern void df_print_word_regset (FILE *file
, bitmap r
);
963 extern void df_dump (FILE *);
964 extern void df_dump_region (FILE *);
965 extern void df_dump_start (FILE *);
966 extern void df_dump_top (basic_block
, FILE *);
967 extern void df_dump_bottom (basic_block
, FILE *);
968 extern void df_dump_insn_top (const_rtx
, FILE *);
969 extern void df_dump_insn_bottom (const_rtx
, FILE *);
970 extern void df_refs_chain_dump (df_ref
, bool, FILE *);
971 extern void df_regs_chain_dump (df_ref
, FILE *);
972 extern void df_insn_debug (rtx
, bool, FILE *);
973 extern void df_insn_debug_regno (rtx
, FILE *);
974 extern void df_regno_debug (unsigned int, FILE *);
975 extern void df_ref_debug (df_ref
, FILE *);
976 extern void debug_df_insn (rtx
);
977 extern void debug_df_regno (unsigned int);
978 extern void debug_df_reg (rtx
);
979 extern void debug_df_defno (unsigned int);
980 extern void debug_df_useno (unsigned int);
981 extern void debug_df_ref (df_ref
);
982 extern void debug_df_chain (struct df_link
*);
984 /* Functions defined in df-problems.c. */
986 extern struct df_link
*df_chain_create (df_ref
, df_ref
);
987 extern void df_chain_unlink (df_ref
);
988 extern void df_chain_copy (df_ref
, struct df_link
*);
989 extern void df_grow_bb_info (struct dataflow
*);
990 extern void df_chain_dump (struct df_link
*, FILE *);
991 extern void df_print_bb_index (basic_block bb
, FILE *file
);
992 extern void df_rd_add_problem (void);
993 extern void df_rd_simulate_artificial_defs_at_top (basic_block
, bitmap
);
994 extern void df_rd_simulate_one_insn (basic_block
, rtx
, bitmap
);
995 extern void df_lr_add_problem (void);
996 extern void df_lr_verify_transfer_functions (void);
997 extern void df_live_verify_transfer_functions (void);
998 extern void df_live_add_problem (void);
999 extern void df_live_set_all_dirty (void);
1000 extern void df_chain_add_problem (unsigned int);
1001 extern void df_word_lr_add_problem (void);
1002 extern bool df_word_lr_mark_ref (df_ref
, bool, bitmap
);
1003 extern bool df_word_lr_simulate_defs (rtx
, bitmap
);
1004 extern void df_word_lr_simulate_uses (rtx
, bitmap
);
1005 extern void df_word_lr_simulate_artificial_refs_at_top (basic_block
, bitmap
);
1006 extern void df_word_lr_simulate_artificial_refs_at_end (basic_block
, bitmap
);
1007 extern void df_note_add_problem (void);
1008 extern void df_md_add_problem (void);
1009 extern void df_md_simulate_artificial_defs_at_top (basic_block
, bitmap
);
1010 extern void df_md_simulate_one_insn (basic_block
, rtx
, bitmap
);
1011 extern void df_simulate_find_noclobber_defs (rtx
, bitmap
);
1012 extern void df_simulate_find_defs (rtx
, bitmap
);
1013 extern void df_simulate_defs (rtx
, bitmap
);
1014 extern void df_simulate_uses (rtx
, bitmap
);
1015 extern void df_simulate_initialize_backwards (basic_block
, bitmap
);
1016 extern void df_simulate_one_insn_backwards (basic_block
, rtx
, bitmap
);
1017 extern void df_simulate_finalize_backwards (basic_block
, bitmap
);
1018 extern void df_simulate_initialize_forwards (basic_block
, bitmap
);
1019 extern void df_simulate_one_insn_forwards (basic_block
, rtx
, bitmap
);
1020 extern void simulate_backwards_to_point (basic_block
, regset
, rtx
);
1021 extern bool can_move_insns_across (rtx
, rtx
, rtx
, rtx
, basic_block
, regset
,
1023 /* Functions defined in df-scan.c. */
1025 extern void df_scan_alloc (bitmap
);
1026 extern void df_scan_add_problem (void);
1027 extern void df_grow_reg_info (void);
1028 extern void df_grow_insn_info (void);
1029 extern void df_scan_blocks (void);
1030 extern void df_uses_create (rtx
*, rtx
, int);
1031 extern struct df_insn_info
* df_insn_create_insn_record (rtx
);
1032 extern void df_insn_delete (rtx
);
1033 extern void df_bb_refs_record (int, bool);
1034 extern bool df_insn_rescan (rtx
);
1035 extern bool df_insn_rescan_debug_internal (rtx
);
1036 extern void df_insn_rescan_all (void);
1037 extern void df_process_deferred_rescans (void);
1038 extern void df_recompute_luids (basic_block
);
1039 extern void df_insn_change_bb (rtx
, basic_block
);
1040 extern void df_maybe_reorganize_use_refs (enum df_ref_order
);
1041 extern void df_maybe_reorganize_def_refs (enum df_ref_order
);
1042 extern void df_ref_change_reg_with_loc (int, int, rtx
);
1043 extern void df_notes_rescan (rtx
);
1044 extern void df_hard_reg_init (void);
1045 extern void df_update_entry_block_defs (void);
1046 extern void df_update_exit_block_uses (void);
1047 extern void df_update_entry_exit_and_calls (void);
1048 extern bool df_hard_reg_used_p (unsigned int);
1049 extern unsigned int df_hard_reg_used_count (unsigned int);
1050 extern bool df_regs_ever_live_p (unsigned int);
1051 extern void df_set_regs_ever_live (unsigned int, bool);
1052 extern void df_compute_regs_ever_live (bool);
1053 extern bool df_read_modify_subreg_p (rtx
);
1054 extern void df_scan_verify (void);
1057 /*----------------------------------------------------------------------------
1058 Public functions access functions for the dataflow problems.
1059 ----------------------------------------------------------------------------*/
1061 static inline struct df_scan_bb_info
*
1062 df_scan_get_bb_info (unsigned int index
)
1064 if (index
< df_scan
->block_info_size
)
1065 return &((struct df_scan_bb_info
*) df_scan
->block_info
)[index
];
1070 static inline struct df_rd_bb_info
*
1071 df_rd_get_bb_info (unsigned int index
)
1073 if (index
< df_rd
->block_info_size
)
1074 return &((struct df_rd_bb_info
*) df_rd
->block_info
)[index
];
1079 static inline struct df_lr_bb_info
*
1080 df_lr_get_bb_info (unsigned int index
)
1082 if (index
< df_lr
->block_info_size
)
1083 return &((struct df_lr_bb_info
*) df_lr
->block_info
)[index
];
1088 static inline struct df_md_bb_info
*
1089 df_md_get_bb_info (unsigned int index
)
1091 if (index
< df_md
->block_info_size
)
1092 return &((struct df_md_bb_info
*) df_md
->block_info
)[index
];
1097 static inline struct df_live_bb_info
*
1098 df_live_get_bb_info (unsigned int index
)
1100 if (index
< df_live
->block_info_size
)
1101 return &((struct df_live_bb_info
*) df_live
->block_info
)[index
];
1106 static inline struct df_word_lr_bb_info
*
1107 df_word_lr_get_bb_info (unsigned int index
)
1109 if (index
< df_word_lr
->block_info_size
)
1110 return &((struct df_word_lr_bb_info
*) df_word_lr
->block_info
)[index
];
1115 /* Get the live at out set for BB no matter what problem happens to be
1116 defined. This function is used by the register allocators who
1117 choose different dataflow problems depending on the optimization
1120 static inline bitmap
1121 df_get_live_out (basic_block bb
)
1123 gcc_checking_assert (df_lr
);
1126 return DF_LIVE_OUT (bb
);
1128 return DF_LR_OUT (bb
);
1131 /* Get the live at in set for BB no matter what problem happens to be
1132 defined. This function is used by the register allocators who
1133 choose different dataflow problems depending on the optimization
1136 static inline bitmap
1137 df_get_live_in (basic_block bb
)
1139 gcc_checking_assert (df_lr
);
1142 return DF_LIVE_IN (bb
);
1144 return DF_LR_IN (bb
);
1147 /* Get basic block info. */
1148 /* Get the artificial defs for a basic block. */
1150 static inline df_ref
1151 df_get_artificial_defs (unsigned int bb_index
)
1153 return df_scan_get_bb_info (bb_index
)->artificial_defs
;
1157 /* Get the artificial uses for a basic block. */
1159 static inline df_ref
1160 df_get_artificial_uses (unsigned int bb_index
)
1162 return df_scan_get_bb_info (bb_index
)->artificial_uses
;
1165 /* If INSN defines exactly one register, return the associated reference,
1166 otherwise return null. */
1168 static inline df_ref
1169 df_single_def (const df_insn_info
*info
)
1171 df_ref defs
= DF_INSN_INFO_DEFS (info
);
1172 return defs
&& !DF_REF_NEXT_LOC (defs
) ? defs
: NULL
;
1175 /* If INSN uses exactly one register, return the associated reference,
1176 otherwise return null. */
1178 static inline df_ref
1179 df_single_use (const df_insn_info
*info
)
1181 df_ref uses
= DF_INSN_INFO_USES (info
);
1182 return uses
&& !DF_REF_NEXT_LOC (uses
) ? uses
: NULL
;
1187 /* This entry is allocated for each reference in the insn stream. */
1190 /* Pointer to the parent in the union/find tree. */
1191 struct web_entry
*pred
;
1192 /* Newly assigned register to the entry. Set only for roots. */
1197 extern struct web_entry
*unionfind_root (struct web_entry
*);
1198 extern bool unionfind_union (struct web_entry
*, struct web_entry
*);
1199 extern void union_defs (df_ref
, struct web_entry
*,
1200 unsigned int *used
, struct web_entry
*,
1201 bool (*fun
) (struct web_entry
*, struct web_entry
*));
1203 #endif /* GCC_DF_H */