1 /* Scanning of rtl for dataflow analysis.
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010, 2011, 2012 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/>. */
27 #include "coretypes.h"
31 #include "insn-config.h"
35 #include "alloc-pool.h"
37 #include "hard-reg-set.h"
38 #include "basic-block.h"
44 #include "target-def.h"
46 #include "emit-rtl.h" /* FIXME: Can go away once crtl is moved to rtl.h. */
49 DEF_VEC_ALLOC_P_STACK(df_ref
);
51 #define VEC_df_ref_stack_alloc(alloc) VEC_stack_alloc (df_ref, alloc)
53 typedef struct df_mw_hardreg
*df_mw_hardreg_ptr
;
55 DEF_VEC_P(df_mw_hardreg_ptr
);
56 DEF_VEC_ALLOC_P_STACK(df_mw_hardreg_ptr
);
58 #define VEC_df_mw_hardreg_ptr_stack_alloc(alloc) \
59 VEC_stack_alloc (df_mw_hardreg_ptr, alloc)
62 #define HAVE_epilogue 0
65 #define HAVE_prologue 0
67 #ifndef HAVE_sibcall_epilogue
68 #define HAVE_sibcall_epilogue 0
72 #define EPILOGUE_USES(REGNO) 0
75 /* The following two macros free the vecs that hold either the refs or
76 the mw refs. They are a little tricky because the vec has 0
77 elements is special and is not to be freed. */
78 #define df_scan_free_ref_vec(V) \
84 #define df_scan_free_mws_vec(V) \
90 /* The set of hard registers in eliminables[i].from. */
92 static HARD_REG_SET elim_reg_set
;
94 /* Initialize ur_in and ur_out as if all hard registers were partially
97 struct df_collection_rec
99 VEC(df_ref
,stack
) *def_vec
;
100 VEC(df_ref
,stack
) *use_vec
;
101 VEC(df_ref
,stack
) *eq_use_vec
;
102 VEC(df_mw_hardreg_ptr
,stack
) *mw_vec
;
105 static df_ref df_null_ref_rec
[1];
106 static struct df_mw_hardreg
* df_null_mw_rec
[1];
108 static void df_ref_record (enum df_ref_class
, struct df_collection_rec
*,
110 basic_block
, struct df_insn_info
*,
111 enum df_ref_type
, int ref_flags
);
112 static void df_def_record_1 (struct df_collection_rec
*, rtx
*,
113 basic_block
, struct df_insn_info
*,
115 static void df_defs_record (struct df_collection_rec
*, rtx
,
116 basic_block
, struct df_insn_info
*,
118 static void df_uses_record (struct df_collection_rec
*,
119 rtx
*, enum df_ref_type
,
120 basic_block
, struct df_insn_info
*,
123 static void df_install_ref_incremental (df_ref
);
124 static df_ref
df_ref_create_structure (enum df_ref_class
,
125 struct df_collection_rec
*, rtx
, rtx
*,
126 basic_block
, struct df_insn_info
*,
127 enum df_ref_type
, int ref_flags
);
128 static void df_insn_refs_collect (struct df_collection_rec
*,
129 basic_block
, struct df_insn_info
*);
130 static void df_canonize_collection_rec (struct df_collection_rec
*);
132 static void df_get_regular_block_artificial_uses (bitmap
);
133 static void df_get_eh_block_artificial_uses (bitmap
);
135 static void df_record_entry_block_defs (bitmap
);
136 static void df_record_exit_block_uses (bitmap
);
137 static void df_get_exit_block_use_set (bitmap
);
138 static void df_get_entry_block_def_set (bitmap
);
139 static void df_grow_ref_info (struct df_ref_info
*, unsigned int);
140 static void df_ref_chain_delete_du_chain (df_ref
*);
141 static void df_ref_chain_delete (df_ref
*);
143 static void df_refs_add_to_chains (struct df_collection_rec
*,
146 static bool df_insn_refs_verify (struct df_collection_rec
*, basic_block
, rtx
, bool);
147 static void df_entry_block_defs_collect (struct df_collection_rec
*, bitmap
);
148 static void df_exit_block_uses_collect (struct df_collection_rec
*, bitmap
);
149 static void df_install_ref (df_ref
, struct df_reg_info
*,
150 struct df_ref_info
*, bool);
152 static int df_ref_compare (const void *, const void *);
153 static int df_mw_compare (const void *, const void *);
155 /* Indexed by hardware reg number, is true if that register is ever
156 used in the current function.
158 In df-scan.c, this is set up to record the hard regs used
159 explicitly. Reload adds in the hard regs used for holding pseudo
160 regs. Final uses it to generate the code in the function prologue
161 and epilogue to save and restore registers as needed. */
163 static bool regs_ever_live
[FIRST_PSEUDO_REGISTER
];
165 /*----------------------------------------------------------------------------
166 SCANNING DATAFLOW PROBLEM
168 There are several ways in which scanning looks just like the other
169 dataflow problems. It shares the all the mechanisms for local info
170 as well as basic block info. Where it differs is when and how often
171 it gets run. It also has no need for the iterative solver.
172 ----------------------------------------------------------------------------*/
174 /* Problem data for the scanning dataflow function. */
175 struct df_scan_problem_data
177 alloc_pool ref_base_pool
;
178 alloc_pool ref_artificial_pool
;
179 alloc_pool ref_regular_pool
;
180 alloc_pool insn_pool
;
182 alloc_pool mw_reg_pool
;
183 bitmap_obstack reg_bitmaps
;
184 bitmap_obstack insn_bitmaps
;
187 typedef struct df_scan_bb_info
*df_scan_bb_info_t
;
190 /* Internal function to shut down the scanning problem. */
192 df_scan_free_internal (void)
194 struct df_scan_problem_data
*problem_data
195 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
199 /* The vectors that hold the refs are not pool allocated because
200 they come in many sizes. This makes them impossible to delete
202 for (i
= 0; i
< DF_INSN_SIZE(); i
++)
204 struct df_insn_info
*insn_info
= DF_INSN_UID_GET(i
);
205 /* Skip the insns that have no insn_info or have been
209 df_scan_free_ref_vec (insn_info
->defs
);
210 df_scan_free_ref_vec (insn_info
->uses
);
211 df_scan_free_ref_vec (insn_info
->eq_uses
);
212 df_scan_free_mws_vec (insn_info
->mw_hardregs
);
218 unsigned int bb_index
= bb
->index
;
219 struct df_scan_bb_info
*bb_info
= df_scan_get_bb_info (bb_index
);
222 df_scan_free_ref_vec (bb_info
->artificial_defs
);
223 df_scan_free_ref_vec (bb_info
->artificial_uses
);
227 free (df
->def_info
.refs
);
228 free (df
->def_info
.begin
);
229 free (df
->def_info
.count
);
230 memset (&df
->def_info
, 0, (sizeof (struct df_ref_info
)));
232 free (df
->use_info
.refs
);
233 free (df
->use_info
.begin
);
234 free (df
->use_info
.count
);
235 memset (&df
->use_info
, 0, (sizeof (struct df_ref_info
)));
241 free (df
->eq_use_regs
);
242 df
->eq_use_regs
= NULL
;
250 free (df_scan
->block_info
);
251 df_scan
->block_info
= NULL
;
252 df_scan
->block_info_size
= 0;
254 bitmap_clear (&df
->hardware_regs_used
);
255 bitmap_clear (&df
->regular_block_artificial_uses
);
256 bitmap_clear (&df
->eh_block_artificial_uses
);
257 BITMAP_FREE (df
->entry_block_defs
);
258 BITMAP_FREE (df
->exit_block_uses
);
259 bitmap_clear (&df
->insns_to_delete
);
260 bitmap_clear (&df
->insns_to_rescan
);
261 bitmap_clear (&df
->insns_to_notes_rescan
);
263 free_alloc_pool (problem_data
->ref_base_pool
);
264 free_alloc_pool (problem_data
->ref_artificial_pool
);
265 free_alloc_pool (problem_data
->ref_regular_pool
);
266 free_alloc_pool (problem_data
->insn_pool
);
267 free_alloc_pool (problem_data
->reg_pool
);
268 free_alloc_pool (problem_data
->mw_reg_pool
);
269 bitmap_obstack_release (&problem_data
->reg_bitmaps
);
270 bitmap_obstack_release (&problem_data
->insn_bitmaps
);
271 free (df_scan
->problem_data
);
275 /* Free basic block info. */
278 df_scan_free_bb_info (basic_block bb
, void *vbb_info
)
280 struct df_scan_bb_info
*bb_info
= (struct df_scan_bb_info
*) vbb_info
;
281 unsigned int bb_index
= bb
->index
;
283 /* See if bb_info is initialized. */
284 if (bb_info
->artificial_defs
)
287 FOR_BB_INSNS (bb
, insn
)
290 /* Record defs within INSN. */
291 df_insn_delete (bb
, INSN_UID (insn
));
294 if (bb_index
< df_scan
->block_info_size
)
295 bb_info
= df_scan_get_bb_info (bb_index
);
297 /* Get rid of any artificial uses or defs. */
298 if (bb_info
->artificial_defs
)
300 df_ref_chain_delete_du_chain (bb_info
->artificial_defs
);
301 df_ref_chain_delete_du_chain (bb_info
->artificial_uses
);
302 df_ref_chain_delete (bb_info
->artificial_defs
);
303 df_ref_chain_delete (bb_info
->artificial_uses
);
304 bb_info
->artificial_defs
= NULL
;
305 bb_info
->artificial_uses
= NULL
;
311 /* Allocate the problem data for the scanning problem. This should be
312 called when the problem is created or when the entire function is to
315 df_scan_alloc (bitmap all_blocks ATTRIBUTE_UNUSED
)
317 struct df_scan_problem_data
*problem_data
;
318 unsigned int insn_num
= get_max_uid () + 1;
319 unsigned int block_size
= 512;
322 /* Given the number of pools, this is really faster than tearing
324 if (df_scan
->problem_data
)
325 df_scan_free_internal ();
327 problem_data
= XNEW (struct df_scan_problem_data
);
328 df_scan
->problem_data
= problem_data
;
329 df_scan
->computed
= true;
331 problem_data
->ref_base_pool
332 = create_alloc_pool ("df_scan ref base",
333 sizeof (struct df_base_ref
), block_size
);
334 problem_data
->ref_artificial_pool
335 = create_alloc_pool ("df_scan ref artificial",
336 sizeof (struct df_artificial_ref
), block_size
);
337 problem_data
->ref_regular_pool
338 = create_alloc_pool ("df_scan ref regular",
339 sizeof (struct df_regular_ref
), block_size
);
340 problem_data
->insn_pool
341 = create_alloc_pool ("df_scan insn",
342 sizeof (struct df_insn_info
), block_size
);
343 problem_data
->reg_pool
344 = create_alloc_pool ("df_scan reg",
345 sizeof (struct df_reg_info
), block_size
);
346 problem_data
->mw_reg_pool
347 = create_alloc_pool ("df_scan mw_reg",
348 sizeof (struct df_mw_hardreg
), block_size
/ 16);
350 bitmap_obstack_initialize (&problem_data
->reg_bitmaps
);
351 bitmap_obstack_initialize (&problem_data
->insn_bitmaps
);
353 insn_num
+= insn_num
/ 4;
356 df_grow_insn_info ();
357 df_grow_bb_info (df_scan
);
361 unsigned int bb_index
= bb
->index
;
362 struct df_scan_bb_info
*bb_info
= df_scan_get_bb_info (bb_index
);
363 bb_info
->artificial_defs
= NULL
;
364 bb_info
->artificial_uses
= NULL
;
367 bitmap_initialize (&df
->hardware_regs_used
, &problem_data
->reg_bitmaps
);
368 bitmap_initialize (&df
->regular_block_artificial_uses
, &problem_data
->reg_bitmaps
);
369 bitmap_initialize (&df
->eh_block_artificial_uses
, &problem_data
->reg_bitmaps
);
370 df
->entry_block_defs
= BITMAP_ALLOC (&problem_data
->reg_bitmaps
);
371 df
->exit_block_uses
= BITMAP_ALLOC (&problem_data
->reg_bitmaps
);
372 bitmap_initialize (&df
->insns_to_delete
, &problem_data
->insn_bitmaps
);
373 bitmap_initialize (&df
->insns_to_rescan
, &problem_data
->insn_bitmaps
);
374 bitmap_initialize (&df
->insns_to_notes_rescan
, &problem_data
->insn_bitmaps
);
375 df_scan
->optional_p
= false;
379 /* Free all of the data associated with the scan problem. */
384 if (df_scan
->problem_data
)
385 df_scan_free_internal ();
387 if (df
->blocks_to_analyze
)
389 BITMAP_FREE (df
->blocks_to_analyze
);
390 df
->blocks_to_analyze
= NULL
;
396 /* Dump the preamble for DF_SCAN dump. */
398 df_scan_start_dump (FILE *file ATTRIBUTE_UNUSED
)
409 fprintf (file
, ";; invalidated by call \t");
410 df_print_regset (file
, regs_invalidated_by_call_regset
);
411 fprintf (file
, ";; hardware regs used \t");
412 df_print_regset (file
, &df
->hardware_regs_used
);
413 fprintf (file
, ";; regular block artificial uses \t");
414 df_print_regset (file
, &df
->regular_block_artificial_uses
);
415 fprintf (file
, ";; eh block artificial uses \t");
416 df_print_regset (file
, &df
->eh_block_artificial_uses
);
417 fprintf (file
, ";; entry block defs \t");
418 df_print_regset (file
, df
->entry_block_defs
);
419 fprintf (file
, ";; exit block uses \t");
420 df_print_regset (file
, df
->exit_block_uses
);
421 fprintf (file
, ";; regs ever live \t");
422 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
423 if (df_regs_ever_live_p (i
))
424 fprintf (file
, " %d[%s]", i
, reg_names
[i
]);
425 fprintf (file
, "\n;; ref usage \t");
427 for (i
= 0; i
< (int)df
->regs_inited
; i
++)
428 if (DF_REG_DEF_COUNT (i
) || DF_REG_USE_COUNT (i
) || DF_REG_EQ_USE_COUNT (i
))
430 const char * sep
= "";
432 fprintf (file
, "r%d={", i
);
433 if (DF_REG_DEF_COUNT (i
))
435 fprintf (file
, "%dd", DF_REG_DEF_COUNT (i
));
437 dcount
+= DF_REG_DEF_COUNT (i
);
439 if (DF_REG_USE_COUNT (i
))
441 fprintf (file
, "%s%du", sep
, DF_REG_USE_COUNT (i
));
443 ucount
+= DF_REG_USE_COUNT (i
);
445 if (DF_REG_EQ_USE_COUNT (i
))
447 fprintf (file
, "%s%de", sep
, DF_REG_EQ_USE_COUNT (i
));
448 ecount
+= DF_REG_EQ_USE_COUNT (i
);
450 fprintf (file
, "} ");
454 FOR_BB_INSNS (bb
, insn
)
463 fprintf (file
, "\n;; total ref usage %d{%dd,%du,%de}"
464 " in %d{%d regular + %d call} insns.\n",
465 dcount
+ ucount
+ ecount
, dcount
, ucount
, ecount
,
466 icount
+ ccount
, icount
, ccount
);
469 /* Dump the bb_info for a given basic block. */
471 df_scan_start_block (basic_block bb
, FILE *file
)
473 struct df_scan_bb_info
*bb_info
474 = df_scan_get_bb_info (bb
->index
);
478 fprintf (file
, ";; bb %d artificial_defs: ", bb
->index
);
479 df_refs_chain_dump (bb_info
->artificial_defs
, true, file
);
480 fprintf (file
, "\n;; bb %d artificial_uses: ", bb
->index
);
481 df_refs_chain_dump (bb_info
->artificial_uses
, true, file
);
482 fprintf (file
, "\n");
487 FOR_BB_INSNS (bb
, insn
)
489 df_insn_debug (insn
, false, file
);
494 static struct df_problem problem_SCAN
=
496 DF_SCAN
, /* Problem id. */
497 DF_NONE
, /* Direction. */
498 df_scan_alloc
, /* Allocate the problem specific data. */
499 NULL
, /* Reset global information. */
500 df_scan_free_bb_info
, /* Free basic block info. */
501 NULL
, /* Local compute function. */
502 NULL
, /* Init the solution specific data. */
503 NULL
, /* Iterative solver. */
504 NULL
, /* Confluence operator 0. */
505 NULL
, /* Confluence operator n. */
506 NULL
, /* Transfer function. */
507 NULL
, /* Finalize function. */
508 df_scan_free
, /* Free all of the problem information. */
509 NULL
, /* Remove this problem from the stack of dataflow problems. */
510 df_scan_start_dump
, /* Debugging. */
511 df_scan_start_block
, /* Debugging start block. */
512 NULL
, /* Debugging end block. */
513 NULL
, /* Debugging start insn. */
514 NULL
, /* Debugging end insn. */
515 NULL
, /* Incremental solution verify start. */
516 NULL
, /* Incremental solution verify end. */
517 NULL
, /* Dependent problem. */
518 sizeof (struct df_scan_bb_info
),/* Size of entry of block_info array. */
519 TV_DF_SCAN
, /* Timing variable. */
520 false /* Reset blocks on dropping out of blocks_to_analyze. */
524 /* Create a new DATAFLOW instance and add it to an existing instance
525 of DF. The returned structure is what is used to get at the
529 df_scan_add_problem (void)
531 df_add_problem (&problem_SCAN
);
535 /*----------------------------------------------------------------------------
536 Storage Allocation Utilities
537 ----------------------------------------------------------------------------*/
540 /* First, grow the reg_info information. If the current size is less than
541 the number of pseudos, grow to 25% more than the number of
544 Second, assure that all of the slots up to max_reg_num have been
545 filled with reg_info structures. */
548 df_grow_reg_info (void)
550 unsigned int max_reg
= max_reg_num ();
551 unsigned int new_size
= max_reg
;
552 struct df_scan_problem_data
*problem_data
553 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
556 if (df
->regs_size
< new_size
)
558 new_size
+= new_size
/ 4;
559 df
->def_regs
= XRESIZEVEC (struct df_reg_info
*, df
->def_regs
, new_size
);
560 df
->use_regs
= XRESIZEVEC (struct df_reg_info
*, df
->use_regs
, new_size
);
561 df
->eq_use_regs
= XRESIZEVEC (struct df_reg_info
*, df
->eq_use_regs
,
563 df
->def_info
.begin
= XRESIZEVEC (unsigned, df
->def_info
.begin
, new_size
);
564 df
->def_info
.count
= XRESIZEVEC (unsigned, df
->def_info
.count
, new_size
);
565 df
->use_info
.begin
= XRESIZEVEC (unsigned, df
->use_info
.begin
, new_size
);
566 df
->use_info
.count
= XRESIZEVEC (unsigned, df
->use_info
.count
, new_size
);
567 df
->regs_size
= new_size
;
570 for (i
= df
->regs_inited
; i
< max_reg
; i
++)
572 struct df_reg_info
*reg_info
;
574 reg_info
= (struct df_reg_info
*) pool_alloc (problem_data
->reg_pool
);
575 memset (reg_info
, 0, sizeof (struct df_reg_info
));
576 df
->def_regs
[i
] = reg_info
;
577 reg_info
= (struct df_reg_info
*) pool_alloc (problem_data
->reg_pool
);
578 memset (reg_info
, 0, sizeof (struct df_reg_info
));
579 df
->use_regs
[i
] = reg_info
;
580 reg_info
= (struct df_reg_info
*) pool_alloc (problem_data
->reg_pool
);
581 memset (reg_info
, 0, sizeof (struct df_reg_info
));
582 df
->eq_use_regs
[i
] = reg_info
;
583 df
->def_info
.begin
[i
] = 0;
584 df
->def_info
.count
[i
] = 0;
585 df
->use_info
.begin
[i
] = 0;
586 df
->use_info
.count
[i
] = 0;
589 df
->regs_inited
= max_reg
;
593 /* Grow the ref information. */
596 df_grow_ref_info (struct df_ref_info
*ref_info
, unsigned int new_size
)
598 if (ref_info
->refs_size
< new_size
)
600 ref_info
->refs
= XRESIZEVEC (df_ref
, ref_info
->refs
, new_size
);
601 memset (ref_info
->refs
+ ref_info
->refs_size
, 0,
602 (new_size
- ref_info
->refs_size
) *sizeof (df_ref
));
603 ref_info
->refs_size
= new_size
;
608 /* Check and grow the ref information if necessary. This routine
609 guarantees total_size + BITMAP_ADDEND amount of entries in refs
610 array. It updates ref_info->refs_size only and does not change
611 ref_info->total_size. */
614 df_check_and_grow_ref_info (struct df_ref_info
*ref_info
,
615 unsigned bitmap_addend
)
617 if (ref_info
->refs_size
< ref_info
->total_size
+ bitmap_addend
)
619 int new_size
= ref_info
->total_size
+ bitmap_addend
;
620 new_size
+= ref_info
->total_size
/ 4;
621 df_grow_ref_info (ref_info
, new_size
);
626 /* Grow the ref information. If the current size is less than the
627 number of instructions, grow to 25% more than the number of
631 df_grow_insn_info (void)
633 unsigned int new_size
= get_max_uid () + 1;
634 if (DF_INSN_SIZE () < new_size
)
636 new_size
+= new_size
/ 4;
637 df
->insns
= XRESIZEVEC (struct df_insn_info
*, df
->insns
, new_size
);
638 memset (df
->insns
+ df
->insns_size
, 0,
639 (new_size
- DF_INSN_SIZE ()) *sizeof (struct df_insn_info
*));
640 DF_INSN_SIZE () = new_size
;
647 /*----------------------------------------------------------------------------
648 PUBLIC INTERFACES FOR SMALL GRAIN CHANGES TO SCANNING.
649 ----------------------------------------------------------------------------*/
651 /* Rescan all of the block_to_analyze or all of the blocks in the
652 function if df_set_blocks if blocks_to_analyze is NULL; */
655 df_scan_blocks (void)
659 df
->def_info
.ref_order
= DF_REF_ORDER_NO_TABLE
;
660 df
->use_info
.ref_order
= DF_REF_ORDER_NO_TABLE
;
662 df_get_regular_block_artificial_uses (&df
->regular_block_artificial_uses
);
663 df_get_eh_block_artificial_uses (&df
->eh_block_artificial_uses
);
665 bitmap_ior_into (&df
->eh_block_artificial_uses
,
666 &df
->regular_block_artificial_uses
);
668 /* ENTRY and EXIT blocks have special defs/uses. */
669 df_get_entry_block_def_set (df
->entry_block_defs
);
670 df_record_entry_block_defs (df
->entry_block_defs
);
671 df_get_exit_block_use_set (df
->exit_block_uses
);
672 df_record_exit_block_uses (df
->exit_block_uses
);
673 df_set_bb_dirty (BASIC_BLOCK (ENTRY_BLOCK
));
674 df_set_bb_dirty (BASIC_BLOCK (EXIT_BLOCK
));
679 unsigned int bb_index
= bb
->index
;
680 df_bb_refs_record (bb_index
, true);
684 /* Create new refs under address LOC within INSN. This function is
685 only used externally. REF_FLAGS must be either 0 or DF_REF_IN_NOTE,
686 depending on whether LOC is inside PATTERN (INSN) or a note. */
689 df_uses_create (rtx
*loc
, rtx insn
, int ref_flags
)
691 gcc_assert (!(ref_flags
& ~DF_REF_IN_NOTE
));
692 df_uses_record (NULL
, loc
, DF_REF_REG_USE
,
693 BLOCK_FOR_INSN (insn
),
694 DF_INSN_INFO_GET (insn
),
698 /* Create a new ref of type DF_REF_TYPE for register REG at address
699 LOC within INSN of BB. This function is only used externally. */
702 df_ref_create (rtx reg
, rtx
*loc
, rtx insn
,
704 enum df_ref_type ref_type
,
707 enum df_ref_class cl
;
711 /* You cannot hack artificial refs. */
719 return df_ref_create_structure (cl
, NULL
, reg
, loc
, bb
,
720 DF_INSN_INFO_GET (insn
),
721 ref_type
, ref_flags
);
725 df_install_ref_incremental (df_ref ref
)
727 struct df_reg_info
**reg_info
;
728 struct df_ref_info
*ref_info
;
730 df_ref
**ref_rec_ptr
;
731 unsigned int count
= 0;
734 rtx insn
= DF_REF_INSN (ref
);
735 basic_block bb
= BLOCK_FOR_INSN (insn
);
737 if (DF_REF_REG_DEF_P (ref
))
739 reg_info
= df
->def_regs
;
740 ref_info
= &df
->def_info
;
741 ref_rec_ptr
= &DF_INSN_DEFS (insn
);
742 add_to_table
= ref_info
->ref_order
!= DF_REF_ORDER_NO_TABLE
;
744 else if (DF_REF_FLAGS (ref
) & DF_REF_IN_NOTE
)
746 reg_info
= df
->eq_use_regs
;
747 ref_info
= &df
->use_info
;
748 ref_rec_ptr
= &DF_INSN_EQ_USES (insn
);
749 switch (ref_info
->ref_order
)
751 case DF_REF_ORDER_UNORDERED_WITH_NOTES
:
752 case DF_REF_ORDER_BY_REG_WITH_NOTES
:
753 case DF_REF_ORDER_BY_INSN_WITH_NOTES
:
757 add_to_table
= false;
763 reg_info
= df
->use_regs
;
764 ref_info
= &df
->use_info
;
765 ref_rec_ptr
= &DF_INSN_USES (insn
);
766 add_to_table
= ref_info
->ref_order
!= DF_REF_ORDER_NO_TABLE
;
769 /* Do not add if ref is not in the right blocks. */
770 if (add_to_table
&& df
->analyze_subset
)
771 add_to_table
= bitmap_bit_p (df
->blocks_to_analyze
, bb
->index
);
773 df_install_ref (ref
, reg_info
[DF_REF_REGNO (ref
)], ref_info
, add_to_table
);
776 switch (ref_info
->ref_order
)
778 case DF_REF_ORDER_UNORDERED_WITH_NOTES
:
779 case DF_REF_ORDER_BY_REG_WITH_NOTES
:
780 case DF_REF_ORDER_BY_INSN_WITH_NOTES
:
781 ref_info
->ref_order
= DF_REF_ORDER_UNORDERED_WITH_NOTES
;
784 ref_info
->ref_order
= DF_REF_ORDER_UNORDERED
;
788 ref_rec
= *ref_rec_ptr
;
795 ref_rec
= *ref_rec_ptr
;
798 ref_rec
= XRESIZEVEC (df_ref
, ref_rec
, count
+2);
799 *ref_rec_ptr
= ref_rec
;
800 ref_rec
[count
] = ref
;
801 ref_rec
[count
+1] = NULL
;
802 qsort (ref_rec
, count
+ 1, sizeof (df_ref
), df_ref_compare
);
806 df_ref
*ref_rec
= XNEWVEC (df_ref
, 2);
809 *ref_rec_ptr
= ref_rec
;
815 fprintf (dump_file
, "adding ref ");
816 df_ref_debug (ref
, dump_file
);
819 /* By adding the ref directly, df_insn_rescan my not find any
820 differences even though the block will have changed. So we need
821 to mark the block dirty ourselves. */
822 if (!DEBUG_INSN_P (DF_REF_INSN (ref
)))
823 df_set_bb_dirty (bb
);
828 /*----------------------------------------------------------------------------
829 UTILITIES TO CREATE AND DESTROY REFS AND CHAINS.
830 ----------------------------------------------------------------------------*/
833 df_free_ref (df_ref ref
)
835 struct df_scan_problem_data
*problem_data
836 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
838 switch (DF_REF_CLASS (ref
))
841 pool_free (problem_data
->ref_base_pool
, ref
);
844 case DF_REF_ARTIFICIAL
:
845 pool_free (problem_data
->ref_artificial_pool
, ref
);
849 pool_free (problem_data
->ref_regular_pool
, ref
);
855 /* Unlink and delete REF at the reg_use, reg_eq_use or reg_def chain.
856 Also delete the def-use or use-def chain if it exists. */
859 df_reg_chain_unlink (df_ref ref
)
861 df_ref next
= DF_REF_NEXT_REG (ref
);
862 df_ref prev
= DF_REF_PREV_REG (ref
);
863 int id
= DF_REF_ID (ref
);
864 struct df_reg_info
*reg_info
;
867 if (DF_REF_REG_DEF_P (ref
))
869 int regno
= DF_REF_REGNO (ref
);
870 reg_info
= DF_REG_DEF_GET (regno
);
871 refs
= df
->def_info
.refs
;
875 if (DF_REF_FLAGS (ref
) & DF_REF_IN_NOTE
)
877 reg_info
= DF_REG_EQ_USE_GET (DF_REF_REGNO (ref
));
878 switch (df
->use_info
.ref_order
)
880 case DF_REF_ORDER_UNORDERED_WITH_NOTES
:
881 case DF_REF_ORDER_BY_REG_WITH_NOTES
:
882 case DF_REF_ORDER_BY_INSN_WITH_NOTES
:
883 refs
= df
->use_info
.refs
;
891 reg_info
= DF_REG_USE_GET (DF_REF_REGNO (ref
));
892 refs
= df
->use_info
.refs
;
898 if (df
->analyze_subset
)
900 if (bitmap_bit_p (df
->blocks_to_analyze
, DF_REF_BBNO (ref
)))
907 /* Delete any def-use or use-def chains that start here. It is
908 possible that there is trash in this field. This happens for
909 insns that have been deleted when rescanning has been deferred
910 and the chain problem has also been deleted. The chain tear down
911 code skips deleted insns. */
912 if (df_chain
&& DF_REF_CHAIN (ref
))
913 df_chain_unlink (ref
);
916 if (DF_REF_FLAGS_IS_SET (ref
, DF_HARD_REG_LIVE
))
918 gcc_assert (DF_REF_REGNO (ref
) < FIRST_PSEUDO_REGISTER
);
919 df
->hard_regs_live_count
[DF_REF_REGNO (ref
)]--;
922 /* Unlink from the reg chain. If there is no prev, this is the
923 first of the list. If not, just join the next and prev. */
925 DF_REF_NEXT_REG (prev
) = next
;
928 gcc_assert (reg_info
->reg_chain
== ref
);
929 reg_info
->reg_chain
= next
;
932 DF_REF_PREV_REG (next
) = prev
;
938 /* Remove REF from VEC. */
941 df_ref_compress_rec (df_ref
**vec_ptr
, df_ref ref
)
943 df_ref
*vec
= *vec_ptr
;
947 while (*vec
&& *vec
!= ref
)
959 *vec_ptr
= df_null_ref_rec
;
964 /* Unlink REF from all def-use/use-def chains, etc. */
967 df_ref_remove (df_ref ref
)
972 fprintf (dump_file
, "removing ref ");
973 df_ref_debug (ref
, dump_file
);
977 if (DF_REF_REG_DEF_P (ref
))
979 if (DF_REF_IS_ARTIFICIAL (ref
))
981 struct df_scan_bb_info
*bb_info
982 = df_scan_get_bb_info (DF_REF_BBNO (ref
));
983 df_ref_compress_rec (&bb_info
->artificial_defs
, ref
);
987 unsigned int uid
= DF_REF_INSN_UID (ref
);
988 struct df_insn_info
*insn_rec
= DF_INSN_UID_GET (uid
);
989 df_ref_compress_rec (&insn_rec
->defs
, ref
);
994 if (DF_REF_IS_ARTIFICIAL (ref
))
996 struct df_scan_bb_info
*bb_info
997 = df_scan_get_bb_info (DF_REF_BBNO (ref
));
998 df_ref_compress_rec (&bb_info
->artificial_uses
, ref
);
1002 unsigned int uid
= DF_REF_INSN_UID (ref
);
1003 struct df_insn_info
*insn_rec
= DF_INSN_UID_GET (uid
);
1005 if (DF_REF_FLAGS (ref
) & DF_REF_IN_NOTE
)
1006 df_ref_compress_rec (&insn_rec
->eq_uses
, ref
);
1008 df_ref_compress_rec (&insn_rec
->uses
, ref
);
1012 /* By deleting the ref directly, df_insn_rescan my not find any
1013 differences even though the block will have changed. So we need
1014 to mark the block dirty ourselves. */
1015 if (!DEBUG_INSN_P (DF_REF_INSN (ref
)))
1016 df_set_bb_dirty (DF_REF_BB (ref
));
1017 df_reg_chain_unlink (ref
);
1021 /* Create the insn record for INSN. If there was one there, zero it
1024 struct df_insn_info
*
1025 df_insn_create_insn_record (rtx insn
)
1027 struct df_scan_problem_data
*problem_data
1028 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
1029 struct df_insn_info
*insn_rec
;
1031 df_grow_insn_info ();
1032 insn_rec
= DF_INSN_INFO_GET (insn
);
1035 insn_rec
= (struct df_insn_info
*) pool_alloc (problem_data
->insn_pool
);
1036 DF_INSN_INFO_SET (insn
, insn_rec
);
1038 memset (insn_rec
, 0, sizeof (struct df_insn_info
));
1039 insn_rec
->insn
= insn
;
1044 /* Delete all du chain (DF_REF_CHAIN()) of all refs in the ref chain. */
1047 df_ref_chain_delete_du_chain (df_ref
*ref_rec
)
1051 df_ref ref
= *ref_rec
;
1052 /* CHAIN is allocated by DF_CHAIN. So make sure to
1053 pass df_scan instance for the problem. */
1054 if (DF_REF_CHAIN (ref
))
1055 df_chain_unlink (ref
);
1061 /* Delete all refs in the ref chain. */
1064 df_ref_chain_delete (df_ref
*ref_rec
)
1066 df_ref
*start
= ref_rec
;
1069 df_reg_chain_unlink (*ref_rec
);
1073 /* If the list is empty, it has a special shared element that is not
1080 /* Delete the hardreg chain. */
1083 df_mw_hardreg_chain_delete (struct df_mw_hardreg
**hardregs
)
1085 struct df_scan_problem_data
*problem_data
;
1090 problem_data
= (struct df_scan_problem_data
*) df_scan
->problem_data
;
1094 pool_free (problem_data
->mw_reg_pool
, *hardregs
);
1100 /* Delete all of the refs information from INSN. BB must be passed in
1101 except when called from df_process_deferred_rescans to mark the block
1105 df_insn_delete (basic_block bb
, unsigned int uid
)
1107 struct df_insn_info
*insn_info
= NULL
;
1111 df_grow_bb_info (df_scan
);
1112 df_grow_reg_info ();
1114 /* The block must be marked as dirty now, rather than later as in
1115 df_insn_rescan and df_notes_rescan because it may not be there at
1116 rescanning time and the mark would blow up. */
1118 df_set_bb_dirty (bb
);
1120 insn_info
= DF_INSN_UID_SAFE_GET (uid
);
1122 /* The client has deferred rescanning. */
1123 if (df
->changeable_flags
& DF_DEFER_INSN_RESCAN
)
1127 bitmap_clear_bit (&df
->insns_to_rescan
, uid
);
1128 bitmap_clear_bit (&df
->insns_to_notes_rescan
, uid
);
1129 bitmap_set_bit (&df
->insns_to_delete
, uid
);
1132 fprintf (dump_file
, "deferring deletion of insn with uid = %d.\n", uid
);
1137 fprintf (dump_file
, "deleting insn with uid = %d.\n", uid
);
1139 bitmap_clear_bit (&df
->insns_to_delete
, uid
);
1140 bitmap_clear_bit (&df
->insns_to_rescan
, uid
);
1141 bitmap_clear_bit (&df
->insns_to_notes_rescan
, uid
);
1144 struct df_scan_problem_data
*problem_data
1145 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
1147 /* In general, notes do not have the insn_info fields
1148 initialized. However, combine deletes insns by changing them
1149 to notes. How clever. So we cannot just check if it is a
1150 valid insn before short circuiting this code, we need to see
1151 if we actually initialized it. */
1152 if (insn_info
->defs
)
1154 df_mw_hardreg_chain_delete (insn_info
->mw_hardregs
);
1158 df_ref_chain_delete_du_chain (insn_info
->defs
);
1159 df_ref_chain_delete_du_chain (insn_info
->uses
);
1160 df_ref_chain_delete_du_chain (insn_info
->eq_uses
);
1163 df_ref_chain_delete (insn_info
->defs
);
1164 df_ref_chain_delete (insn_info
->uses
);
1165 df_ref_chain_delete (insn_info
->eq_uses
);
1167 pool_free (problem_data
->insn_pool
, insn_info
);
1168 DF_INSN_UID_SET (uid
, NULL
);
1173 /* Free all of the refs and the mw_hardregs in COLLECTION_REC. */
1176 df_free_collection_rec (struct df_collection_rec
*collection_rec
)
1179 struct df_scan_problem_data
*problem_data
1180 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
1182 struct df_mw_hardreg
*mw
;
1184 FOR_EACH_VEC_ELT (df_ref
, collection_rec
->def_vec
, ix
, ref
)
1186 FOR_EACH_VEC_ELT (df_ref
, collection_rec
->use_vec
, ix
, ref
)
1188 FOR_EACH_VEC_ELT (df_ref
, collection_rec
->eq_use_vec
, ix
, ref
)
1190 FOR_EACH_VEC_ELT (df_mw_hardreg_ptr
, collection_rec
->mw_vec
, ix
, mw
)
1191 pool_free (problem_data
->mw_reg_pool
, mw
);
1193 VEC_free (df_ref
, stack
, collection_rec
->def_vec
);
1194 VEC_free (df_ref
, stack
, collection_rec
->use_vec
);
1195 VEC_free (df_ref
, stack
, collection_rec
->eq_use_vec
);
1196 VEC_free (df_mw_hardreg_ptr
, stack
, collection_rec
->mw_vec
);
1199 /* Rescan INSN. Return TRUE if the rescanning produced any changes. */
1202 df_insn_rescan (rtx insn
)
1204 unsigned int uid
= INSN_UID (insn
);
1205 struct df_insn_info
*insn_info
= NULL
;
1206 basic_block bb
= BLOCK_FOR_INSN (insn
);
1207 struct df_collection_rec collection_rec
;
1209 if ((!df
) || (!INSN_P (insn
)))
1215 fprintf (dump_file
, "no bb for insn with uid = %d.\n", uid
);
1219 /* The client has disabled rescanning and plans to do it itself. */
1220 if (df
->changeable_flags
& DF_NO_INSN_RESCAN
)
1223 df_grow_bb_info (df_scan
);
1224 df_grow_reg_info ();
1226 insn_info
= DF_INSN_UID_SAFE_GET (uid
);
1228 /* The client has deferred rescanning. */
1229 if (df
->changeable_flags
& DF_DEFER_INSN_RESCAN
)
1233 insn_info
= df_insn_create_insn_record (insn
);
1234 insn_info
->defs
= df_null_ref_rec
;
1235 insn_info
->uses
= df_null_ref_rec
;
1236 insn_info
->eq_uses
= df_null_ref_rec
;
1237 insn_info
->mw_hardregs
= df_null_mw_rec
;
1240 fprintf (dump_file
, "deferring rescan insn with uid = %d.\n", uid
);
1242 bitmap_clear_bit (&df
->insns_to_delete
, uid
);
1243 bitmap_clear_bit (&df
->insns_to_notes_rescan
, uid
);
1244 bitmap_set_bit (&df
->insns_to_rescan
, INSN_UID (insn
));
1248 collection_rec
.def_vec
= VEC_alloc (df_ref
, stack
, 128);
1249 collection_rec
.use_vec
= VEC_alloc (df_ref
, stack
, 32);
1250 collection_rec
.eq_use_vec
= VEC_alloc (df_ref
, stack
, 32);
1251 collection_rec
.mw_vec
= VEC_alloc (df_mw_hardreg_ptr
, stack
, 32);
1253 bitmap_clear_bit (&df
->insns_to_delete
, uid
);
1254 bitmap_clear_bit (&df
->insns_to_rescan
, uid
);
1255 bitmap_clear_bit (&df
->insns_to_notes_rescan
, uid
);
1259 bool the_same
= df_insn_refs_verify (&collection_rec
, bb
, insn
, false);
1260 /* If there's no change, return false. */
1263 df_free_collection_rec (&collection_rec
);
1265 fprintf (dump_file
, "verify found no changes in insn with uid = %d.\n", uid
);
1269 fprintf (dump_file
, "rescanning insn with uid = %d.\n", uid
);
1271 /* There's change - we need to delete the existing info.
1272 Since the insn isn't moved, we can salvage its LUID. */
1273 luid
= DF_INSN_LUID (insn
);
1274 df_insn_delete (NULL
, uid
);
1275 df_insn_create_insn_record (insn
);
1276 DF_INSN_LUID (insn
) = luid
;
1280 struct df_insn_info
*insn_info
= df_insn_create_insn_record (insn
);
1281 df_insn_refs_collect (&collection_rec
, bb
, insn_info
);
1283 fprintf (dump_file
, "scanning new insn with uid = %d.\n", uid
);
1286 df_refs_add_to_chains (&collection_rec
, bb
, insn
);
1287 if (!DEBUG_INSN_P (insn
))
1288 df_set_bb_dirty (bb
);
1290 VEC_free (df_ref
, stack
, collection_rec
.def_vec
);
1291 VEC_free (df_ref
, stack
, collection_rec
.use_vec
);
1292 VEC_free (df_ref
, stack
, collection_rec
.eq_use_vec
);
1293 VEC_free (df_mw_hardreg_ptr
, stack
, collection_rec
.mw_vec
);
1298 /* Same as df_insn_rescan, but don't mark the basic block as
1302 df_insn_rescan_debug_internal (rtx insn
)
1304 unsigned int uid
= INSN_UID (insn
);
1305 struct df_insn_info
*insn_info
;
1307 gcc_assert (DEBUG_INSN_P (insn
)
1308 && VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn
)));
1313 insn_info
= DF_INSN_UID_SAFE_GET (INSN_UID (insn
));
1318 fprintf (dump_file
, "deleting debug_insn with uid = %d.\n", uid
);
1320 bitmap_clear_bit (&df
->insns_to_delete
, uid
);
1321 bitmap_clear_bit (&df
->insns_to_rescan
, uid
);
1322 bitmap_clear_bit (&df
->insns_to_notes_rescan
, uid
);
1324 if (!insn_info
->defs
)
1327 if (insn_info
->defs
== df_null_ref_rec
1328 && insn_info
->uses
== df_null_ref_rec
1329 && insn_info
->eq_uses
== df_null_ref_rec
1330 && insn_info
->mw_hardregs
== df_null_mw_rec
)
1333 df_mw_hardreg_chain_delete (insn_info
->mw_hardregs
);
1337 df_ref_chain_delete_du_chain (insn_info
->defs
);
1338 df_ref_chain_delete_du_chain (insn_info
->uses
);
1339 df_ref_chain_delete_du_chain (insn_info
->eq_uses
);
1342 df_ref_chain_delete (insn_info
->defs
);
1343 df_ref_chain_delete (insn_info
->uses
);
1344 df_ref_chain_delete (insn_info
->eq_uses
);
1346 insn_info
->defs
= df_null_ref_rec
;
1347 insn_info
->uses
= df_null_ref_rec
;
1348 insn_info
->eq_uses
= df_null_ref_rec
;
1349 insn_info
->mw_hardregs
= df_null_mw_rec
;
1355 /* Rescan all of the insns in the function. Note that the artificial
1356 uses and defs are not touched. This function will destroy def-se
1357 or use-def chains. */
1360 df_insn_rescan_all (void)
1362 bool no_insn_rescan
= false;
1363 bool defer_insn_rescan
= false;
1369 bitmap_initialize (&tmp
, &df_bitmap_obstack
);
1371 if (df
->changeable_flags
& DF_NO_INSN_RESCAN
)
1373 df_clear_flags (DF_NO_INSN_RESCAN
);
1374 no_insn_rescan
= true;
1377 if (df
->changeable_flags
& DF_DEFER_INSN_RESCAN
)
1379 df_clear_flags (DF_DEFER_INSN_RESCAN
);
1380 defer_insn_rescan
= true;
1383 bitmap_copy (&tmp
, &df
->insns_to_delete
);
1384 EXECUTE_IF_SET_IN_BITMAP (&tmp
, 0, uid
, bi
)
1386 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
1388 df_insn_delete (NULL
, uid
);
1391 bitmap_clear (&tmp
);
1392 bitmap_clear (&df
->insns_to_delete
);
1393 bitmap_clear (&df
->insns_to_rescan
);
1394 bitmap_clear (&df
->insns_to_notes_rescan
);
1399 FOR_BB_INSNS (bb
, insn
)
1401 df_insn_rescan (insn
);
1406 df_set_flags (DF_NO_INSN_RESCAN
);
1407 if (defer_insn_rescan
)
1408 df_set_flags (DF_DEFER_INSN_RESCAN
);
1412 /* Process all of the deferred rescans or deletions. */
1415 df_process_deferred_rescans (void)
1417 bool no_insn_rescan
= false;
1418 bool defer_insn_rescan
= false;
1423 bitmap_initialize (&tmp
, &df_bitmap_obstack
);
1425 if (df
->changeable_flags
& DF_NO_INSN_RESCAN
)
1427 df_clear_flags (DF_NO_INSN_RESCAN
);
1428 no_insn_rescan
= true;
1431 if (df
->changeable_flags
& DF_DEFER_INSN_RESCAN
)
1433 df_clear_flags (DF_DEFER_INSN_RESCAN
);
1434 defer_insn_rescan
= true;
1438 fprintf (dump_file
, "starting the processing of deferred insns\n");
1440 bitmap_copy (&tmp
, &df
->insns_to_delete
);
1441 EXECUTE_IF_SET_IN_BITMAP (&tmp
, 0, uid
, bi
)
1443 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
1445 df_insn_delete (NULL
, uid
);
1448 bitmap_copy (&tmp
, &df
->insns_to_rescan
);
1449 EXECUTE_IF_SET_IN_BITMAP (&tmp
, 0, uid
, bi
)
1451 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
1453 df_insn_rescan (insn_info
->insn
);
1456 bitmap_copy (&tmp
, &df
->insns_to_notes_rescan
);
1457 EXECUTE_IF_SET_IN_BITMAP (&tmp
, 0, uid
, bi
)
1459 struct df_insn_info
*insn_info
= DF_INSN_UID_SAFE_GET (uid
);
1461 df_notes_rescan (insn_info
->insn
);
1465 fprintf (dump_file
, "ending the processing of deferred insns\n");
1467 bitmap_clear (&tmp
);
1468 bitmap_clear (&df
->insns_to_delete
);
1469 bitmap_clear (&df
->insns_to_rescan
);
1470 bitmap_clear (&df
->insns_to_notes_rescan
);
1473 df_set_flags (DF_NO_INSN_RESCAN
);
1474 if (defer_insn_rescan
)
1475 df_set_flags (DF_DEFER_INSN_RESCAN
);
1477 /* If someone changed regs_ever_live during this pass, fix up the
1478 entry and exit blocks. */
1479 if (df
->redo_entry_and_exit
)
1481 df_update_entry_exit_and_calls ();
1482 df
->redo_entry_and_exit
= false;
1487 /* Count the number of refs. Include the defs if INCLUDE_DEFS. Include
1488 the uses if INCLUDE_USES. Include the eq_uses if
1492 df_count_refs (bool include_defs
, bool include_uses
,
1493 bool include_eq_uses
)
1497 unsigned int m
= df
->regs_inited
;
1499 for (regno
= 0; regno
< m
; regno
++)
1502 size
+= DF_REG_DEF_COUNT (regno
);
1504 size
+= DF_REG_USE_COUNT (regno
);
1505 if (include_eq_uses
)
1506 size
+= DF_REG_EQ_USE_COUNT (regno
);
1512 /* Take build ref table for either the uses or defs from the reg-use
1513 or reg-def chains. This version processes the refs in reg order
1514 which is likely to be best if processing the whole function. */
1517 df_reorganize_refs_by_reg_by_reg (struct df_ref_info
*ref_info
,
1520 bool include_eq_uses
)
1522 unsigned int m
= df
->regs_inited
;
1524 unsigned int offset
= 0;
1527 if (df
->changeable_flags
& DF_NO_HARD_REGS
)
1529 start
= FIRST_PSEUDO_REGISTER
;
1530 memset (ref_info
->begin
, 0, sizeof (int) * FIRST_PSEUDO_REGISTER
);
1531 memset (ref_info
->count
, 0, sizeof (int) * FIRST_PSEUDO_REGISTER
);
1536 ref_info
->total_size
1537 = df_count_refs (include_defs
, include_uses
, include_eq_uses
);
1539 df_check_and_grow_ref_info (ref_info
, 1);
1541 for (regno
= start
; regno
< m
; regno
++)
1544 ref_info
->begin
[regno
] = offset
;
1547 df_ref ref
= DF_REG_DEF_CHAIN (regno
);
1550 ref_info
->refs
[offset
] = ref
;
1551 DF_REF_ID (ref
) = offset
++;
1553 ref
= DF_REF_NEXT_REG (ref
);
1554 gcc_checking_assert (offset
< ref_info
->refs_size
);
1559 df_ref ref
= DF_REG_USE_CHAIN (regno
);
1562 ref_info
->refs
[offset
] = ref
;
1563 DF_REF_ID (ref
) = offset
++;
1565 ref
= DF_REF_NEXT_REG (ref
);
1566 gcc_checking_assert (offset
< ref_info
->refs_size
);
1569 if (include_eq_uses
)
1571 df_ref ref
= DF_REG_EQ_USE_CHAIN (regno
);
1574 ref_info
->refs
[offset
] = ref
;
1575 DF_REF_ID (ref
) = offset
++;
1577 ref
= DF_REF_NEXT_REG (ref
);
1578 gcc_checking_assert (offset
< ref_info
->refs_size
);
1581 ref_info
->count
[regno
] = count
;
1584 /* The bitmap size is not decremented when refs are deleted. So
1585 reset it now that we have squished out all of the empty
1587 ref_info
->table_size
= offset
;
1591 /* Take build ref table for either the uses or defs from the reg-use
1592 or reg-def chains. This version processes the refs in insn order
1593 which is likely to be best if processing some segment of the
1597 df_reorganize_refs_by_reg_by_insn (struct df_ref_info
*ref_info
,
1600 bool include_eq_uses
)
1603 unsigned int bb_index
;
1604 unsigned int m
= df
->regs_inited
;
1605 unsigned int offset
= 0;
1608 = (df
->changeable_flags
& DF_NO_HARD_REGS
) ? FIRST_PSEUDO_REGISTER
: 0;
1610 memset (ref_info
->begin
, 0, sizeof (int) * df
->regs_inited
);
1611 memset (ref_info
->count
, 0, sizeof (int) * df
->regs_inited
);
1613 ref_info
->total_size
= df_count_refs (include_defs
, include_uses
, include_eq_uses
);
1614 df_check_and_grow_ref_info (ref_info
, 1);
1616 EXECUTE_IF_SET_IN_BITMAP (df
->blocks_to_analyze
, 0, bb_index
, bi
)
1618 basic_block bb
= BASIC_BLOCK (bb_index
);
1623 for (ref_rec
= df_get_artificial_defs (bb_index
); *ref_rec
; ref_rec
++)
1625 unsigned int regno
= DF_REF_REGNO (*ref_rec
);
1626 ref_info
->count
[regno
]++;
1629 for (ref_rec
= df_get_artificial_uses (bb_index
); *ref_rec
; ref_rec
++)
1631 unsigned int regno
= DF_REF_REGNO (*ref_rec
);
1632 ref_info
->count
[regno
]++;
1635 FOR_BB_INSNS (bb
, insn
)
1639 unsigned int uid
= INSN_UID (insn
);
1642 for (ref_rec
= DF_INSN_UID_DEFS (uid
); *ref_rec
; ref_rec
++)
1644 unsigned int regno
= DF_REF_REGNO (*ref_rec
);
1645 ref_info
->count
[regno
]++;
1648 for (ref_rec
= DF_INSN_UID_USES (uid
); *ref_rec
; ref_rec
++)
1650 unsigned int regno
= DF_REF_REGNO (*ref_rec
);
1651 ref_info
->count
[regno
]++;
1653 if (include_eq_uses
)
1654 for (ref_rec
= DF_INSN_UID_EQ_USES (uid
); *ref_rec
; ref_rec
++)
1656 unsigned int regno
= DF_REF_REGNO (*ref_rec
);
1657 ref_info
->count
[regno
]++;
1663 for (r
= start
; r
< m
; r
++)
1665 ref_info
->begin
[r
] = offset
;
1666 offset
+= ref_info
->count
[r
];
1667 ref_info
->count
[r
] = 0;
1670 EXECUTE_IF_SET_IN_BITMAP (df
->blocks_to_analyze
, 0, bb_index
, bi
)
1672 basic_block bb
= BASIC_BLOCK (bb_index
);
1677 for (ref_rec
= df_get_artificial_defs (bb_index
); *ref_rec
; ref_rec
++)
1679 df_ref ref
= *ref_rec
;
1680 unsigned int regno
= DF_REF_REGNO (ref
);
1684 = ref_info
->begin
[regno
] + ref_info
->count
[regno
]++;
1685 DF_REF_ID (ref
) = id
;
1686 ref_info
->refs
[id
] = ref
;
1690 for (ref_rec
= df_get_artificial_uses (bb_index
); *ref_rec
; ref_rec
++)
1692 df_ref ref
= *ref_rec
;
1693 unsigned int regno
= DF_REF_REGNO (ref
);
1697 = ref_info
->begin
[regno
] + ref_info
->count
[regno
]++;
1698 DF_REF_ID (ref
) = id
;
1699 ref_info
->refs
[id
] = ref
;
1703 FOR_BB_INSNS (bb
, insn
)
1707 unsigned int uid
= INSN_UID (insn
);
1710 for (ref_rec
= DF_INSN_UID_DEFS (uid
); *ref_rec
; ref_rec
++)
1712 df_ref ref
= *ref_rec
;
1713 unsigned int regno
= DF_REF_REGNO (ref
);
1717 = ref_info
->begin
[regno
] + ref_info
->count
[regno
]++;
1718 DF_REF_ID (ref
) = id
;
1719 ref_info
->refs
[id
] = ref
;
1723 for (ref_rec
= DF_INSN_UID_USES (uid
); *ref_rec
; ref_rec
++)
1725 df_ref ref
= *ref_rec
;
1726 unsigned int regno
= DF_REF_REGNO (ref
);
1730 = ref_info
->begin
[regno
] + ref_info
->count
[regno
]++;
1731 DF_REF_ID (ref
) = id
;
1732 ref_info
->refs
[id
] = ref
;
1735 if (include_eq_uses
)
1736 for (ref_rec
= DF_INSN_UID_EQ_USES (uid
); *ref_rec
; ref_rec
++)
1738 df_ref ref
= *ref_rec
;
1739 unsigned int regno
= DF_REF_REGNO (ref
);
1743 = ref_info
->begin
[regno
] + ref_info
->count
[regno
]++;
1744 DF_REF_ID (ref
) = id
;
1745 ref_info
->refs
[id
] = ref
;
1752 /* The bitmap size is not decremented when refs are deleted. So
1753 reset it now that we have squished out all of the empty
1756 ref_info
->table_size
= offset
;
1759 /* Take build ref table for either the uses or defs from the reg-use
1760 or reg-def chains. */
1763 df_reorganize_refs_by_reg (struct df_ref_info
*ref_info
,
1766 bool include_eq_uses
)
1768 if (df
->analyze_subset
)
1769 df_reorganize_refs_by_reg_by_insn (ref_info
, include_defs
,
1770 include_uses
, include_eq_uses
);
1772 df_reorganize_refs_by_reg_by_reg (ref_info
, include_defs
,
1773 include_uses
, include_eq_uses
);
1777 /* Add the refs in REF_VEC to the table in REF_INFO starting at OFFSET. */
1779 df_add_refs_to_table (unsigned int offset
,
1780 struct df_ref_info
*ref_info
,
1785 df_ref ref
= *ref_vec
;
1786 if ((!(df
->changeable_flags
& DF_NO_HARD_REGS
))
1787 || (DF_REF_REGNO (ref
) >= FIRST_PSEUDO_REGISTER
))
1789 ref_info
->refs
[offset
] = ref
;
1790 DF_REF_ID (*ref_vec
) = offset
++;
1798 /* Count the number of refs in all of the insns of BB. Include the
1799 defs if INCLUDE_DEFS. Include the uses if INCLUDE_USES. Include the
1800 eq_uses if INCLUDE_EQ_USES. */
1803 df_reorganize_refs_by_insn_bb (basic_block bb
, unsigned int offset
,
1804 struct df_ref_info
*ref_info
,
1805 bool include_defs
, bool include_uses
,
1806 bool include_eq_uses
)
1811 offset
= df_add_refs_to_table (offset
, ref_info
,
1812 df_get_artificial_defs (bb
->index
));
1814 offset
= df_add_refs_to_table (offset
, ref_info
,
1815 df_get_artificial_uses (bb
->index
));
1817 FOR_BB_INSNS (bb
, insn
)
1820 unsigned int uid
= INSN_UID (insn
);
1822 offset
= df_add_refs_to_table (offset
, ref_info
,
1823 DF_INSN_UID_DEFS (uid
));
1825 offset
= df_add_refs_to_table (offset
, ref_info
,
1826 DF_INSN_UID_USES (uid
));
1827 if (include_eq_uses
)
1828 offset
= df_add_refs_to_table (offset
, ref_info
,
1829 DF_INSN_UID_EQ_USES (uid
));
1835 /* Organize the refs by insn into the table in REF_INFO. If
1836 blocks_to_analyze is defined, use that set, otherwise the entire
1837 program. Include the defs if INCLUDE_DEFS. Include the uses if
1838 INCLUDE_USES. Include the eq_uses if INCLUDE_EQ_USES. */
1841 df_reorganize_refs_by_insn (struct df_ref_info
*ref_info
,
1842 bool include_defs
, bool include_uses
,
1843 bool include_eq_uses
)
1846 unsigned int offset
= 0;
1848 ref_info
->total_size
= df_count_refs (include_defs
, include_uses
, include_eq_uses
);
1849 df_check_and_grow_ref_info (ref_info
, 1);
1850 if (df
->blocks_to_analyze
)
1855 EXECUTE_IF_SET_IN_BITMAP (df
->blocks_to_analyze
, 0, index
, bi
)
1857 offset
= df_reorganize_refs_by_insn_bb (BASIC_BLOCK (index
), offset
, ref_info
,
1858 include_defs
, include_uses
,
1862 ref_info
->table_size
= offset
;
1867 offset
= df_reorganize_refs_by_insn_bb (bb
, offset
, ref_info
,
1868 include_defs
, include_uses
,
1870 ref_info
->table_size
= offset
;
1875 /* If the use refs in DF are not organized, reorganize them. */
1878 df_maybe_reorganize_use_refs (enum df_ref_order order
)
1880 if (order
== df
->use_info
.ref_order
)
1885 case DF_REF_ORDER_BY_REG
:
1886 df_reorganize_refs_by_reg (&df
->use_info
, false, true, false);
1889 case DF_REF_ORDER_BY_REG_WITH_NOTES
:
1890 df_reorganize_refs_by_reg (&df
->use_info
, false, true, true);
1893 case DF_REF_ORDER_BY_INSN
:
1894 df_reorganize_refs_by_insn (&df
->use_info
, false, true, false);
1897 case DF_REF_ORDER_BY_INSN_WITH_NOTES
:
1898 df_reorganize_refs_by_insn (&df
->use_info
, false, true, true);
1901 case DF_REF_ORDER_NO_TABLE
:
1902 free (df
->use_info
.refs
);
1903 df
->use_info
.refs
= NULL
;
1904 df
->use_info
.refs_size
= 0;
1907 case DF_REF_ORDER_UNORDERED
:
1908 case DF_REF_ORDER_UNORDERED_WITH_NOTES
:
1913 df
->use_info
.ref_order
= order
;
1917 /* If the def refs in DF are not organized, reorganize them. */
1920 df_maybe_reorganize_def_refs (enum df_ref_order order
)
1922 if (order
== df
->def_info
.ref_order
)
1927 case DF_REF_ORDER_BY_REG
:
1928 df_reorganize_refs_by_reg (&df
->def_info
, true, false, false);
1931 case DF_REF_ORDER_BY_INSN
:
1932 df_reorganize_refs_by_insn (&df
->def_info
, true, false, false);
1935 case DF_REF_ORDER_NO_TABLE
:
1936 free (df
->def_info
.refs
);
1937 df
->def_info
.refs
= NULL
;
1938 df
->def_info
.refs_size
= 0;
1941 case DF_REF_ORDER_BY_INSN_WITH_NOTES
:
1942 case DF_REF_ORDER_BY_REG_WITH_NOTES
:
1943 case DF_REF_ORDER_UNORDERED
:
1944 case DF_REF_ORDER_UNORDERED_WITH_NOTES
:
1949 df
->def_info
.ref_order
= order
;
1953 /* Change all of the basic block references in INSN to use the insn's
1954 current basic block. This function is called from routines that move
1955 instructions from one block to another. */
1958 df_insn_change_bb (rtx insn
, basic_block new_bb
)
1960 basic_block old_bb
= BLOCK_FOR_INSN (insn
);
1961 struct df_insn_info
*insn_info
;
1962 unsigned int uid
= INSN_UID (insn
);
1964 if (old_bb
== new_bb
)
1967 set_block_for_insn (insn
, new_bb
);
1973 fprintf (dump_file
, "changing bb of uid %d\n", uid
);
1975 insn_info
= DF_INSN_UID_SAFE_GET (uid
);
1976 if (insn_info
== NULL
)
1979 fprintf (dump_file
, " unscanned insn\n");
1980 df_insn_rescan (insn
);
1987 df_set_bb_dirty (new_bb
);
1991 fprintf (dump_file
, " from %d to %d\n",
1992 old_bb
->index
, new_bb
->index
);
1993 df_set_bb_dirty (old_bb
);
1997 fprintf (dump_file
, " to %d\n", new_bb
->index
);
2001 /* Helper function for df_ref_change_reg_with_loc. */
2004 df_ref_change_reg_with_loc_1 (struct df_reg_info
*old_df
,
2005 struct df_reg_info
*new_df
,
2006 int new_regno
, rtx loc
)
2008 df_ref the_ref
= old_df
->reg_chain
;
2012 if ((!DF_REF_IS_ARTIFICIAL (the_ref
))
2013 && DF_REF_LOC (the_ref
)
2014 && (*DF_REF_LOC (the_ref
) == loc
))
2016 df_ref next_ref
= DF_REF_NEXT_REG (the_ref
);
2017 df_ref prev_ref
= DF_REF_PREV_REG (the_ref
);
2018 df_ref
*ref_vec
, *ref_vec_t
;
2019 struct df_insn_info
*insn_info
= DF_REF_INSN_INFO (the_ref
);
2020 unsigned int count
= 0;
2022 DF_REF_REGNO (the_ref
) = new_regno
;
2023 DF_REF_REG (the_ref
) = regno_reg_rtx
[new_regno
];
2025 /* Pull the_ref out of the old regno chain. */
2027 DF_REF_NEXT_REG (prev_ref
) = next_ref
;
2029 old_df
->reg_chain
= next_ref
;
2031 DF_REF_PREV_REG (next_ref
) = prev_ref
;
2034 /* Put the ref into the new regno chain. */
2035 DF_REF_PREV_REG (the_ref
) = NULL
;
2036 DF_REF_NEXT_REG (the_ref
) = new_df
->reg_chain
;
2037 if (new_df
->reg_chain
)
2038 DF_REF_PREV_REG (new_df
->reg_chain
) = the_ref
;
2039 new_df
->reg_chain
= the_ref
;
2041 if (DF_REF_BB (the_ref
))
2042 df_set_bb_dirty (DF_REF_BB (the_ref
));
2044 /* Need to sort the record again that the ref was in because
2045 the regno is a sorting key. First, find the right
2047 if (DF_REF_FLAGS (the_ref
) & DF_REF_IN_NOTE
)
2048 ref_vec
= insn_info
->eq_uses
;
2050 ref_vec
= insn_info
->uses
;
2052 fprintf (dump_file
, "changing reg in insn %d\n",
2053 DF_REF_INSN_UID (the_ref
));
2055 ref_vec_t
= ref_vec
;
2057 /* Find the length. */
2063 qsort (ref_vec
, count
, sizeof (df_ref
), df_ref_compare
);
2068 the_ref
= DF_REF_NEXT_REG (the_ref
);
2073 /* Change the regno of all refs that contained LOC from OLD_REGNO to
2074 NEW_REGNO. Refs that do not match LOC are not changed which means
2075 that artificial refs are not changed since they have no loc. This
2076 call is to support the SET_REGNO macro. */
2079 df_ref_change_reg_with_loc (int old_regno
, int new_regno
, rtx loc
)
2081 if ((!df
) || (old_regno
== -1) || (old_regno
== new_regno
))
2084 df_grow_reg_info ();
2086 df_ref_change_reg_with_loc_1 (DF_REG_DEF_GET (old_regno
),
2087 DF_REG_DEF_GET (new_regno
), new_regno
, loc
);
2088 df_ref_change_reg_with_loc_1 (DF_REG_USE_GET (old_regno
),
2089 DF_REG_USE_GET (new_regno
), new_regno
, loc
);
2090 df_ref_change_reg_with_loc_1 (DF_REG_EQ_USE_GET (old_regno
),
2091 DF_REG_EQ_USE_GET (new_regno
), new_regno
, loc
);
2095 /* Delete the mw_hardregs that point into the eq_notes. */
2098 df_mw_hardreg_chain_delete_eq_uses (struct df_insn_info
*insn_info
)
2100 struct df_mw_hardreg
**mw_vec
= insn_info
->mw_hardregs
;
2101 unsigned int deleted
= 0;
2102 unsigned int count
= 0;
2103 struct df_scan_problem_data
*problem_data
2104 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
2111 if ((*mw_vec
)->flags
& DF_REF_IN_NOTE
)
2113 struct df_mw_hardreg
**temp_vec
= mw_vec
;
2115 pool_free (problem_data
->mw_reg_pool
, *mw_vec
);
2117 /* Shove the remaining ones down one to fill the gap. While
2118 this looks n**2, it is highly unusual to have any mw regs
2119 in eq_notes and the chances of more than one are almost
2123 *temp_vec
= *(temp_vec
+ 1);
2137 df_scan_free_mws_vec (insn_info
->mw_hardregs
);
2138 insn_info
->mw_hardregs
= df_null_mw_rec
;
2145 /* Rescan only the REG_EQUIV/REG_EQUAL notes part of INSN. */
2148 df_notes_rescan (rtx insn
)
2150 struct df_insn_info
*insn_info
;
2151 unsigned int uid
= INSN_UID (insn
);
2156 /* The client has disabled rescanning and plans to do it itself. */
2157 if (df
->changeable_flags
& DF_NO_INSN_RESCAN
)
2160 /* Do nothing if the insn hasn't been emitted yet. */
2161 if (!BLOCK_FOR_INSN (insn
))
2164 df_grow_bb_info (df_scan
);
2165 df_grow_reg_info ();
2167 insn_info
= DF_INSN_UID_SAFE_GET (INSN_UID(insn
));
2169 /* The client has deferred rescanning. */
2170 if (df
->changeable_flags
& DF_DEFER_INSN_RESCAN
)
2174 insn_info
= df_insn_create_insn_record (insn
);
2175 insn_info
->defs
= df_null_ref_rec
;
2176 insn_info
->uses
= df_null_ref_rec
;
2177 insn_info
->eq_uses
= df_null_ref_rec
;
2178 insn_info
->mw_hardregs
= df_null_mw_rec
;
2181 bitmap_clear_bit (&df
->insns_to_delete
, uid
);
2182 /* If the insn is set to be rescanned, it does not need to also
2183 be notes rescanned. */
2184 if (!bitmap_bit_p (&df
->insns_to_rescan
, uid
))
2185 bitmap_set_bit (&df
->insns_to_notes_rescan
, INSN_UID (insn
));
2189 bitmap_clear_bit (&df
->insns_to_delete
, uid
);
2190 bitmap_clear_bit (&df
->insns_to_notes_rescan
, uid
);
2194 basic_block bb
= BLOCK_FOR_INSN (insn
);
2196 struct df_collection_rec collection_rec
;
2197 unsigned int num_deleted
;
2198 unsigned int mw_len
;
2200 memset (&collection_rec
, 0, sizeof (struct df_collection_rec
));
2201 collection_rec
.eq_use_vec
= VEC_alloc (df_ref
, stack
, 32);
2202 collection_rec
.mw_vec
= VEC_alloc (df_mw_hardreg_ptr
, stack
, 32);
2204 num_deleted
= df_mw_hardreg_chain_delete_eq_uses (insn_info
);
2205 df_ref_chain_delete (insn_info
->eq_uses
);
2206 insn_info
->eq_uses
= NULL
;
2208 /* Process REG_EQUIV/REG_EQUAL notes */
2209 for (note
= REG_NOTES (insn
); note
;
2210 note
= XEXP (note
, 1))
2212 switch (REG_NOTE_KIND (note
))
2216 df_uses_record (&collection_rec
,
2217 &XEXP (note
, 0), DF_REF_REG_USE
,
2218 bb
, insn_info
, DF_REF_IN_NOTE
);
2224 /* Find some place to put any new mw_hardregs. */
2225 df_canonize_collection_rec (&collection_rec
);
2226 mw_len
= VEC_length (df_mw_hardreg_ptr
, collection_rec
.mw_vec
);
2229 unsigned int count
= 0;
2230 struct df_mw_hardreg
**mw_rec
= insn_info
->mw_hardregs
;
2239 /* Append to the end of the existing record after
2240 expanding it if necessary. */
2241 if (mw_len
> num_deleted
)
2243 insn_info
->mw_hardregs
=
2244 XRESIZEVEC (struct df_mw_hardreg
*,
2245 insn_info
->mw_hardregs
,
2246 count
+ 1 + mw_len
);
2248 memcpy (&insn_info
->mw_hardregs
[count
],
2249 VEC_address (df_mw_hardreg_ptr
, collection_rec
.mw_vec
),
2250 mw_len
* sizeof (struct df_mw_hardreg
*));
2251 insn_info
->mw_hardregs
[count
+ mw_len
] = NULL
;
2252 qsort (insn_info
->mw_hardregs
, count
+ mw_len
,
2253 sizeof (struct df_mw_hardreg
*), df_mw_compare
);
2257 /* No vector there. */
2258 insn_info
->mw_hardregs
2259 = XNEWVEC (struct df_mw_hardreg
*, 1 + mw_len
);
2260 memcpy (insn_info
->mw_hardregs
,
2261 VEC_address (df_mw_hardreg_ptr
, collection_rec
.mw_vec
),
2262 mw_len
* sizeof (struct df_mw_hardreg
*));
2263 insn_info
->mw_hardregs
[mw_len
] = NULL
;
2266 /* Get rid of the mw_rec so that df_refs_add_to_chains will
2268 VEC_free (df_mw_hardreg_ptr
, stack
, collection_rec
.mw_vec
);
2269 df_refs_add_to_chains (&collection_rec
, bb
, insn
);
2270 VEC_free (df_ref
, stack
, collection_rec
.eq_use_vec
);
2273 df_insn_rescan (insn
);
2278 /*----------------------------------------------------------------------------
2279 Hard core instruction scanning code. No external interfaces here,
2280 just a lot of routines that look inside insns.
2281 ----------------------------------------------------------------------------*/
2284 /* Return true if the contents of two df_ref's are identical.
2285 It ignores DF_REF_MARKER. */
2288 df_ref_equal_p (df_ref ref1
, df_ref ref2
)
2296 if (DF_REF_CLASS (ref1
) != DF_REF_CLASS (ref2
)
2297 || DF_REF_REGNO (ref1
) != DF_REF_REGNO (ref2
)
2298 || DF_REF_REG (ref1
) != DF_REF_REG (ref2
)
2299 || DF_REF_TYPE (ref1
) != DF_REF_TYPE (ref2
)
2300 || ((DF_REF_FLAGS (ref1
) & ~(DF_REF_REG_MARKER
+ DF_REF_MW_HARDREG
))
2301 != (DF_REF_FLAGS (ref2
) & ~(DF_REF_REG_MARKER
+ DF_REF_MW_HARDREG
)))
2302 || DF_REF_BB (ref1
) != DF_REF_BB (ref2
)
2303 || DF_REF_INSN_INFO (ref1
) != DF_REF_INSN_INFO (ref2
))
2306 switch (DF_REF_CLASS (ref1
))
2308 case DF_REF_ARTIFICIAL
:
2312 case DF_REF_REGULAR
:
2313 return DF_REF_LOC (ref1
) == DF_REF_LOC (ref2
);
2322 /* Compare REF1 and REF2 for sorting. This is only called from places
2323 where all of the refs are of the same type, in the same insn, and
2324 have the same bb. So these fields are not checked. */
2327 df_ref_compare (const void *r1
, const void *r2
)
2329 const df_ref ref1
= *(const df_ref
*)r1
;
2330 const df_ref ref2
= *(const df_ref
*)r2
;
2335 if (DF_REF_CLASS (ref1
) != DF_REF_CLASS (ref2
))
2336 return (int)DF_REF_CLASS (ref1
) - (int)DF_REF_CLASS (ref2
);
2338 if (DF_REF_REGNO (ref1
) != DF_REF_REGNO (ref2
))
2339 return (int)DF_REF_REGNO (ref1
) - (int)DF_REF_REGNO (ref2
);
2341 if (DF_REF_TYPE (ref1
) != DF_REF_TYPE (ref2
))
2342 return (int)DF_REF_TYPE (ref1
) - (int)DF_REF_TYPE (ref2
);
2344 if (DF_REF_REG (ref1
) != DF_REF_REG (ref2
))
2345 return (int)DF_REF_ORDER (ref1
) - (int)DF_REF_ORDER (ref2
);
2347 /* Cannot look at the LOC field on artificial refs. */
2348 if (DF_REF_CLASS (ref1
) != DF_REF_ARTIFICIAL
2349 && DF_REF_LOC (ref1
) != DF_REF_LOC (ref2
))
2350 return (int)DF_REF_ORDER (ref1
) - (int)DF_REF_ORDER (ref2
);
2352 if (DF_REF_FLAGS (ref1
) != DF_REF_FLAGS (ref2
))
2354 /* If two refs are identical except that one of them has is from
2355 a mw and one is not, we need to have the one with the mw
2357 if (DF_REF_FLAGS_IS_SET (ref1
, DF_REF_MW_HARDREG
) ==
2358 DF_REF_FLAGS_IS_SET (ref2
, DF_REF_MW_HARDREG
))
2359 return DF_REF_FLAGS (ref1
) - DF_REF_FLAGS (ref2
);
2360 else if (DF_REF_FLAGS_IS_SET (ref1
, DF_REF_MW_HARDREG
))
2366 return (int)DF_REF_ORDER (ref1
) - (int)DF_REF_ORDER (ref2
);
2370 df_swap_refs (VEC(df_ref
,stack
) **ref_vec
, int i
, int j
)
2372 df_ref tmp
= VEC_index (df_ref
, *ref_vec
, i
);
2373 VEC_replace (df_ref
, *ref_vec
, i
, VEC_index (df_ref
, *ref_vec
, j
));
2374 VEC_replace (df_ref
, *ref_vec
, j
, tmp
);
2377 /* Sort and compress a set of refs. */
2380 df_sort_and_compress_refs (VEC(df_ref
,stack
) **ref_vec
)
2384 unsigned int dist
= 0;
2386 count
= VEC_length (df_ref
, *ref_vec
);
2388 /* If there are 1 or 0 elements, there is nothing to do. */
2391 else if (count
== 2)
2393 df_ref r0
= VEC_index (df_ref
, *ref_vec
, 0);
2394 df_ref r1
= VEC_index (df_ref
, *ref_vec
, 1);
2395 if (df_ref_compare (&r0
, &r1
) > 0)
2396 df_swap_refs (ref_vec
, 0, 1);
2400 for (i
= 0; i
< count
- 1; i
++)
2402 df_ref r0
= VEC_index (df_ref
, *ref_vec
, i
);
2403 df_ref r1
= VEC_index (df_ref
, *ref_vec
, i
+ 1);
2404 if (df_ref_compare (&r0
, &r1
) >= 0)
2407 /* If the array is already strictly ordered,
2408 which is the most common case for large COUNT case
2409 (which happens for CALL INSNs),
2410 no need to sort and filter out duplicate.
2411 Simply return the count.
2412 Make sure DF_GET_ADD_REFS adds refs in the increasing order
2413 of DF_REF_COMPARE. */
2416 VEC_qsort (df_ref
, *ref_vec
, df_ref_compare
);
2419 for (i
=0; i
<count
-dist
; i
++)
2421 /* Find the next ref that is not equal to the current ref. */
2422 while (i
+ dist
+ 1 < count
2423 && df_ref_equal_p (VEC_index (df_ref
, *ref_vec
, i
),
2424 VEC_index (df_ref
, *ref_vec
, i
+ dist
+ 1)))
2426 df_free_ref (VEC_index (df_ref
, *ref_vec
, i
+ dist
+ 1));
2429 /* Copy it down to the next position. */
2430 if (dist
&& i
+ dist
+ 1 < count
)
2431 VEC_replace (df_ref
, *ref_vec
, i
+ 1,
2432 VEC_index (df_ref
, *ref_vec
, i
+ dist
+ 1));
2436 VEC_truncate (df_ref
, *ref_vec
, count
);
2440 /* Return true if the contents of two df_ref's are identical.
2441 It ignores DF_REF_MARKER. */
2444 df_mw_equal_p (struct df_mw_hardreg
*mw1
, struct df_mw_hardreg
*mw2
)
2448 return (mw1
== mw2
) ||
2449 (mw1
->mw_reg
== mw2
->mw_reg
2450 && mw1
->type
== mw2
->type
2451 && mw1
->flags
== mw2
->flags
2452 && mw1
->start_regno
== mw2
->start_regno
2453 && mw1
->end_regno
== mw2
->end_regno
);
2457 /* Compare MW1 and MW2 for sorting. */
2460 df_mw_compare (const void *m1
, const void *m2
)
2462 const struct df_mw_hardreg
*const mw1
= *(const struct df_mw_hardreg
*const*)m1
;
2463 const struct df_mw_hardreg
*const mw2
= *(const struct df_mw_hardreg
*const*)m2
;
2468 if (mw1
->type
!= mw2
->type
)
2469 return mw1
->type
- mw2
->type
;
2471 if (mw1
->flags
!= mw2
->flags
)
2472 return mw1
->flags
- mw2
->flags
;
2474 if (mw1
->start_regno
!= mw2
->start_regno
)
2475 return mw1
->start_regno
- mw2
->start_regno
;
2477 if (mw1
->end_regno
!= mw2
->end_regno
)
2478 return mw1
->end_regno
- mw2
->end_regno
;
2480 if (mw1
->mw_reg
!= mw2
->mw_reg
)
2481 return mw1
->mw_order
- mw2
->mw_order
;
2487 /* Sort and compress a set of refs. */
2490 df_sort_and_compress_mws (VEC(df_mw_hardreg_ptr
,stack
) **mw_vec
)
2493 struct df_scan_problem_data
*problem_data
2494 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
2496 unsigned int dist
= 0;
2498 count
= VEC_length (df_mw_hardreg_ptr
, *mw_vec
);
2501 else if (count
== 2)
2503 struct df_mw_hardreg
*m0
= VEC_index (df_mw_hardreg_ptr
, *mw_vec
, 0);
2504 struct df_mw_hardreg
*m1
= VEC_index (df_mw_hardreg_ptr
, *mw_vec
, 1);
2505 if (df_mw_compare (&m0
, &m1
) > 0)
2507 struct df_mw_hardreg
*tmp
= VEC_index (df_mw_hardreg_ptr
,
2509 VEC_replace (df_mw_hardreg_ptr
, *mw_vec
, 0,
2510 VEC_index (df_mw_hardreg_ptr
, *mw_vec
, 1));
2511 VEC_replace (df_mw_hardreg_ptr
, *mw_vec
, 1, tmp
);
2515 VEC_qsort (df_mw_hardreg_ptr
, *mw_vec
, df_mw_compare
);
2517 for (i
=0; i
<count
-dist
; i
++)
2519 /* Find the next ref that is not equal to the current ref. */
2520 while (i
+ dist
+ 1 < count
2521 && df_mw_equal_p (VEC_index (df_mw_hardreg_ptr
, *mw_vec
, i
),
2522 VEC_index (df_mw_hardreg_ptr
, *mw_vec
,
2525 pool_free (problem_data
->mw_reg_pool
,
2526 VEC_index (df_mw_hardreg_ptr
, *mw_vec
, i
+ dist
+ 1));
2529 /* Copy it down to the next position. */
2530 if (dist
&& i
+ dist
+ 1 < count
)
2531 VEC_replace (df_mw_hardreg_ptr
, *mw_vec
, i
+ 1,
2532 VEC_index (df_mw_hardreg_ptr
, *mw_vec
, i
+ dist
+ 1));
2536 VEC_truncate (df_mw_hardreg_ptr
, *mw_vec
, count
);
2540 /* Sort and remove duplicates from the COLLECTION_REC. */
2543 df_canonize_collection_rec (struct df_collection_rec
*collection_rec
)
2545 df_sort_and_compress_refs (&collection_rec
->def_vec
);
2546 df_sort_and_compress_refs (&collection_rec
->use_vec
);
2547 df_sort_and_compress_refs (&collection_rec
->eq_use_vec
);
2548 df_sort_and_compress_mws (&collection_rec
->mw_vec
);
2552 /* Add the new df_ref to appropriate reg_info/ref_info chains. */
2555 df_install_ref (df_ref this_ref
,
2556 struct df_reg_info
*reg_info
,
2557 struct df_ref_info
*ref_info
,
2560 unsigned int regno
= DF_REF_REGNO (this_ref
);
2561 /* Add the ref to the reg_{def,use,eq_use} chain. */
2562 df_ref head
= reg_info
->reg_chain
;
2564 reg_info
->reg_chain
= this_ref
;
2567 if (DF_REF_FLAGS_IS_SET (this_ref
, DF_HARD_REG_LIVE
))
2569 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
2570 df
->hard_regs_live_count
[regno
]++;
2573 gcc_checking_assert (DF_REF_NEXT_REG (this_ref
) == NULL
2574 && DF_REF_PREV_REG (this_ref
) == NULL
);
2576 DF_REF_NEXT_REG (this_ref
) = head
;
2578 /* We cannot actually link to the head of the chain. */
2579 DF_REF_PREV_REG (this_ref
) = NULL
;
2582 DF_REF_PREV_REG (head
) = this_ref
;
2586 gcc_assert (ref_info
->ref_order
!= DF_REF_ORDER_NO_TABLE
);
2587 df_check_and_grow_ref_info (ref_info
, 1);
2588 DF_REF_ID (this_ref
) = ref_info
->table_size
;
2589 /* Add the ref to the big array of defs. */
2590 ref_info
->refs
[ref_info
->table_size
] = this_ref
;
2591 ref_info
->table_size
++;
2594 DF_REF_ID (this_ref
) = -1;
2596 ref_info
->total_size
++;
2600 /* This function takes one of the groups of refs (defs, uses or
2601 eq_uses) and installs the entire group into the insn. It also adds
2602 each of these refs into the appropriate chains. */
2605 df_install_refs (basic_block bb
,
2606 VEC(df_ref
,stack
)* old_vec
,
2607 struct df_reg_info
**reg_info
,
2608 struct df_ref_info
*ref_info
,
2613 count
= VEC_length (df_ref
, old_vec
);
2616 df_ref
*new_vec
= XNEWVEC (df_ref
, count
+ 1);
2621 switch (ref_info
->ref_order
)
2623 case DF_REF_ORDER_UNORDERED_WITH_NOTES
:
2624 case DF_REF_ORDER_BY_REG_WITH_NOTES
:
2625 case DF_REF_ORDER_BY_INSN_WITH_NOTES
:
2626 ref_info
->ref_order
= DF_REF_ORDER_UNORDERED_WITH_NOTES
;
2627 add_to_table
= true;
2629 case DF_REF_ORDER_UNORDERED
:
2630 case DF_REF_ORDER_BY_REG
:
2631 case DF_REF_ORDER_BY_INSN
:
2632 ref_info
->ref_order
= DF_REF_ORDER_UNORDERED
;
2633 add_to_table
= !is_notes
;
2636 add_to_table
= false;
2640 /* Do not add if ref is not in the right blocks. */
2641 if (add_to_table
&& df
->analyze_subset
)
2642 add_to_table
= bitmap_bit_p (df
->blocks_to_analyze
, bb
->index
);
2644 FOR_EACH_VEC_ELT (df_ref
, old_vec
, ix
, this_ref
)
2646 new_vec
[ix
] = this_ref
;
2647 df_install_ref (this_ref
, reg_info
[DF_REF_REGNO (this_ref
)],
2648 ref_info
, add_to_table
);
2651 new_vec
[count
] = NULL
;
2655 return df_null_ref_rec
;
2659 /* This function takes the mws installs the entire group into the
2662 static struct df_mw_hardreg
**
2663 df_install_mws (VEC(df_mw_hardreg_ptr
,stack
) *old_vec
)
2667 count
= VEC_length (df_mw_hardreg_ptr
, old_vec
);
2670 struct df_mw_hardreg
**new_vec
2671 = XNEWVEC (struct df_mw_hardreg
*, count
+ 1);
2672 memcpy (new_vec
, VEC_address (df_mw_hardreg_ptr
, old_vec
),
2673 sizeof (struct df_mw_hardreg
*) * count
);
2674 new_vec
[count
] = NULL
;
2678 return df_null_mw_rec
;
2682 /* Add a chain of df_refs to appropriate ref chain/reg_info/ref_info
2683 chains and update other necessary information. */
2686 df_refs_add_to_chains (struct df_collection_rec
*collection_rec
,
2687 basic_block bb
, rtx insn
)
2691 struct df_insn_info
*insn_rec
= DF_INSN_INFO_GET (insn
);
2692 /* If there is a vector in the collection rec, add it to the
2693 insn. A null rec is a signal that the caller will handle the
2695 if (collection_rec
->def_vec
)
2697 df_scan_free_ref_vec (insn_rec
->defs
);
2699 = df_install_refs (bb
, collection_rec
->def_vec
,
2701 &df
->def_info
, false);
2703 if (collection_rec
->use_vec
)
2705 df_scan_free_ref_vec (insn_rec
->uses
);
2707 = df_install_refs (bb
, collection_rec
->use_vec
,
2709 &df
->use_info
, false);
2711 if (collection_rec
->eq_use_vec
)
2713 df_scan_free_ref_vec (insn_rec
->eq_uses
);
2715 = df_install_refs (bb
, collection_rec
->eq_use_vec
,
2717 &df
->use_info
, true);
2719 if (collection_rec
->mw_vec
)
2721 df_scan_free_mws_vec (insn_rec
->mw_hardregs
);
2722 insn_rec
->mw_hardregs
2723 = df_install_mws (collection_rec
->mw_vec
);
2728 struct df_scan_bb_info
*bb_info
= df_scan_get_bb_info (bb
->index
);
2730 df_scan_free_ref_vec (bb_info
->artificial_defs
);
2731 bb_info
->artificial_defs
2732 = df_install_refs (bb
, collection_rec
->def_vec
,
2734 &df
->def_info
, false);
2735 df_scan_free_ref_vec (bb_info
->artificial_uses
);
2736 bb_info
->artificial_uses
2737 = df_install_refs (bb
, collection_rec
->use_vec
,
2739 &df
->use_info
, false);
2744 /* Allocate a ref and initialize its fields. */
2747 df_ref_create_structure (enum df_ref_class cl
,
2748 struct df_collection_rec
*collection_rec
,
2750 basic_block bb
, struct df_insn_info
*info
,
2751 enum df_ref_type ref_type
,
2754 df_ref this_ref
= NULL
;
2755 int regno
= REGNO (GET_CODE (reg
) == SUBREG
? SUBREG_REG (reg
) : reg
);
2756 struct df_scan_problem_data
*problem_data
2757 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
2762 this_ref
= (df_ref
) pool_alloc (problem_data
->ref_base_pool
);
2763 gcc_checking_assert (loc
== NULL
);
2766 case DF_REF_ARTIFICIAL
:
2767 this_ref
= (df_ref
) pool_alloc (problem_data
->ref_artificial_pool
);
2768 this_ref
->artificial_ref
.bb
= bb
;
2769 gcc_checking_assert (loc
== NULL
);
2772 case DF_REF_REGULAR
:
2773 this_ref
= (df_ref
) pool_alloc (problem_data
->ref_regular_pool
);
2774 this_ref
->regular_ref
.loc
= loc
;
2775 gcc_checking_assert (loc
);
2779 DF_REF_CLASS (this_ref
) = cl
;
2780 DF_REF_ID (this_ref
) = -1;
2781 DF_REF_REG (this_ref
) = reg
;
2782 DF_REF_REGNO (this_ref
) = regno
;
2783 DF_REF_TYPE (this_ref
) = ref_type
;
2784 DF_REF_INSN_INFO (this_ref
) = info
;
2785 DF_REF_CHAIN (this_ref
) = NULL
;
2786 DF_REF_FLAGS (this_ref
) = ref_flags
;
2787 DF_REF_NEXT_REG (this_ref
) = NULL
;
2788 DF_REF_PREV_REG (this_ref
) = NULL
;
2789 DF_REF_ORDER (this_ref
) = df
->ref_order
++;
2791 /* We need to clear this bit because fwprop, and in the future
2792 possibly other optimizations sometimes create new refs using ond
2793 refs as the model. */
2794 DF_REF_FLAGS_CLEAR (this_ref
, DF_HARD_REG_LIVE
);
2796 /* See if this ref needs to have DF_HARD_REG_LIVE bit set. */
2797 if (regno
< FIRST_PSEUDO_REGISTER
2798 && !DF_REF_IS_ARTIFICIAL (this_ref
)
2799 && !DEBUG_INSN_P (DF_REF_INSN (this_ref
)))
2801 if (DF_REF_REG_DEF_P (this_ref
))
2803 if (!DF_REF_FLAGS_IS_SET (this_ref
, DF_REF_MAY_CLOBBER
))
2804 DF_REF_FLAGS_SET (this_ref
, DF_HARD_REG_LIVE
);
2806 else if (!(TEST_HARD_REG_BIT (elim_reg_set
, regno
)
2807 && (regno
== FRAME_POINTER_REGNUM
2808 || regno
== ARG_POINTER_REGNUM
)))
2809 DF_REF_FLAGS_SET (this_ref
, DF_HARD_REG_LIVE
);
2814 if (DF_REF_REG_DEF_P (this_ref
))
2815 VEC_safe_push (df_ref
, stack
, collection_rec
->def_vec
, this_ref
);
2816 else if (DF_REF_FLAGS (this_ref
) & DF_REF_IN_NOTE
)
2817 VEC_safe_push (df_ref
, stack
, collection_rec
->eq_use_vec
, this_ref
);
2819 VEC_safe_push (df_ref
, stack
, collection_rec
->use_vec
, this_ref
);
2822 df_install_ref_incremental (this_ref
);
2828 /* Create new references of type DF_REF_TYPE for each part of register REG
2829 at address LOC within INSN of BB. */
2833 df_ref_record (enum df_ref_class cl
,
2834 struct df_collection_rec
*collection_rec
,
2836 basic_block bb
, struct df_insn_info
*insn_info
,
2837 enum df_ref_type ref_type
,
2842 gcc_checking_assert (REG_P (reg
) || GET_CODE (reg
) == SUBREG
);
2844 regno
= REGNO (GET_CODE (reg
) == SUBREG
? SUBREG_REG (reg
) : reg
);
2845 if (regno
< FIRST_PSEUDO_REGISTER
)
2847 struct df_mw_hardreg
*hardreg
= NULL
;
2848 struct df_scan_problem_data
*problem_data
2849 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
2851 unsigned int endregno
;
2854 if (GET_CODE (reg
) == SUBREG
)
2856 regno
+= subreg_regno_offset (regno
, GET_MODE (SUBREG_REG (reg
)),
2857 SUBREG_BYTE (reg
), GET_MODE (reg
));
2858 endregno
= regno
+ subreg_nregs (reg
);
2861 endregno
= END_HARD_REGNO (reg
);
2863 /* If this is a multiword hardreg, we create some extra
2864 datastructures that will enable us to easily build REG_DEAD
2865 and REG_UNUSED notes. */
2867 && (endregno
!= regno
+ 1) && insn_info
)
2869 /* Sets to a subreg of a multiword register are partial.
2870 Sets to a non-subreg of a multiword register are not. */
2871 if (GET_CODE (reg
) == SUBREG
)
2872 ref_flags
|= DF_REF_PARTIAL
;
2873 ref_flags
|= DF_REF_MW_HARDREG
;
2875 hardreg
= (struct df_mw_hardreg
*) pool_alloc (problem_data
->mw_reg_pool
);
2876 hardreg
->type
= ref_type
;
2877 hardreg
->flags
= ref_flags
;
2878 hardreg
->mw_reg
= reg
;
2879 hardreg
->start_regno
= regno
;
2880 hardreg
->end_regno
= endregno
- 1;
2881 hardreg
->mw_order
= df
->ref_order
++;
2882 VEC_safe_push (df_mw_hardreg_ptr
, stack
, collection_rec
->mw_vec
,
2886 for (i
= regno
; i
< endregno
; i
++)
2888 ref
= df_ref_create_structure (cl
, collection_rec
, regno_reg_rtx
[i
], loc
,
2889 bb
, insn_info
, ref_type
, ref_flags
);
2891 gcc_assert (ORIGINAL_REGNO (DF_REF_REG (ref
)) == i
);
2896 df_ref_create_structure (cl
, collection_rec
, reg
, loc
, bb
, insn_info
,
2897 ref_type
, ref_flags
);
2902 /* A set to a non-paradoxical SUBREG for which the number of word_mode units
2903 covered by the outer mode is smaller than that covered by the inner mode,
2904 is a read-modify-write operation.
2905 This function returns true iff the SUBREG X is such a SUBREG. */
2908 df_read_modify_subreg_p (rtx x
)
2910 unsigned int isize
, osize
;
2911 if (GET_CODE (x
) != SUBREG
)
2913 isize
= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x
)));
2914 osize
= GET_MODE_SIZE (GET_MODE (x
));
2915 return isize
> osize
2916 && isize
> REGMODE_NATURAL_SIZE (GET_MODE (SUBREG_REG (x
)));
2920 /* Process all the registers defined in the rtx pointed by LOC.
2921 Autoincrement/decrement definitions will be picked up by df_uses_record.
2922 Any change here has to be matched in df_find_hard_reg_defs_1. */
2925 df_def_record_1 (struct df_collection_rec
*collection_rec
,
2926 rtx
*loc
, basic_block bb
, struct df_insn_info
*insn_info
,
2931 /* It is legal to have a set destination be a parallel. */
2932 if (GET_CODE (dst
) == PARALLEL
)
2935 for (i
= XVECLEN (dst
, 0) - 1; i
>= 0; i
--)
2937 rtx temp
= XVECEXP (dst
, 0, i
);
2938 gcc_assert (GET_CODE (temp
) == EXPR_LIST
);
2939 df_def_record_1 (collection_rec
, &XEXP (temp
, 0),
2940 bb
, insn_info
, flags
);
2945 if (GET_CODE (dst
) == STRICT_LOW_PART
)
2947 flags
|= DF_REF_READ_WRITE
| DF_REF_PARTIAL
| DF_REF_STRICT_LOW_PART
;
2949 loc
= &XEXP (dst
, 0);
2953 if (GET_CODE (dst
) == ZERO_EXTRACT
)
2955 flags
|= DF_REF_READ_WRITE
| DF_REF_PARTIAL
| DF_REF_ZERO_EXTRACT
;
2957 loc
= &XEXP (dst
, 0);
2961 /* At this point if we do not have a reg or a subreg, just return. */
2964 df_ref_record (DF_REF_REGULAR
, collection_rec
,
2965 dst
, loc
, bb
, insn_info
, DF_REF_REG_DEF
, flags
);
2967 /* We want to keep sp alive everywhere - by making all
2968 writes to sp also use of sp. */
2969 if (REGNO (dst
) == STACK_POINTER_REGNUM
)
2970 df_ref_record (DF_REF_BASE
, collection_rec
,
2971 dst
, NULL
, bb
, insn_info
, DF_REF_REG_USE
, flags
);
2973 else if (GET_CODE (dst
) == SUBREG
&& REG_P (SUBREG_REG (dst
)))
2975 if (df_read_modify_subreg_p (dst
))
2976 flags
|= DF_REF_READ_WRITE
| DF_REF_PARTIAL
;
2978 flags
|= DF_REF_SUBREG
;
2980 df_ref_record (DF_REF_REGULAR
, collection_rec
,
2981 dst
, loc
, bb
, insn_info
, DF_REF_REG_DEF
, flags
);
2986 /* Process all the registers defined in the pattern rtx, X. Any change
2987 here has to be matched in df_find_hard_reg_defs. */
2990 df_defs_record (struct df_collection_rec
*collection_rec
,
2991 rtx x
, basic_block bb
, struct df_insn_info
*insn_info
,
2994 RTX_CODE code
= GET_CODE (x
);
3000 df_def_record_1 (collection_rec
, &SET_DEST (x
), bb
, insn_info
, flags
);
3004 flags
|= DF_REF_MUST_CLOBBER
;
3005 df_def_record_1 (collection_rec
, &XEXP (x
, 0), bb
, insn_info
, flags
);
3009 df_defs_record (collection_rec
, COND_EXEC_CODE (x
),
3010 bb
, insn_info
, DF_REF_CONDITIONAL
);
3014 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
3015 df_defs_record (collection_rec
, XVECEXP (x
, 0, i
),
3016 bb
, insn_info
, flags
);
3019 /* No DEFs to record in other cases */
3024 /* Set bits in *DEFS for hard registers found in the rtx DST, which is the
3025 destination of a set or clobber. This has to match the logic in
3026 df_defs_record_1. */
3029 df_find_hard_reg_defs_1 (rtx dst
, HARD_REG_SET
*defs
)
3031 /* It is legal to have a set destination be a parallel. */
3032 if (GET_CODE (dst
) == PARALLEL
)
3035 for (i
= XVECLEN (dst
, 0) - 1; i
>= 0; i
--)
3037 rtx temp
= XVECEXP (dst
, 0, i
);
3038 gcc_assert (GET_CODE (temp
) == EXPR_LIST
);
3039 df_find_hard_reg_defs_1 (XEXP (temp
, 0), defs
);
3044 if (GET_CODE (dst
) == STRICT_LOW_PART
)
3045 dst
= XEXP (dst
, 0);
3047 if (GET_CODE (dst
) == ZERO_EXTRACT
)
3048 dst
= XEXP (dst
, 0);
3050 /* At this point if we do not have a reg or a subreg, just return. */
3051 if (REG_P (dst
) && HARD_REGISTER_P (dst
))
3052 SET_HARD_REG_BIT (*defs
, REGNO (dst
));
3053 else if (GET_CODE (dst
) == SUBREG
3054 && REG_P (SUBREG_REG (dst
)) && HARD_REGISTER_P (dst
))
3055 SET_HARD_REG_BIT (*defs
, REGNO (SUBREG_REG (dst
)));
3058 /* Set bits in *DEFS for hard registers defined in the pattern X. This
3059 has to match the logic in df_defs_record. */
3062 df_find_hard_reg_defs (rtx x
, HARD_REG_SET
*defs
)
3064 RTX_CODE code
= GET_CODE (x
);
3070 df_find_hard_reg_defs_1 (SET_DEST (x
), defs
);
3074 df_find_hard_reg_defs_1 (XEXP (x
, 0), defs
);
3078 df_find_hard_reg_defs (COND_EXEC_CODE (x
), defs
);
3082 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
3083 df_find_hard_reg_defs (XVECEXP (x
, 0, i
), defs
);
3086 /* No DEFs to record in other cases */
3092 /* Process all the registers used in the rtx at address LOC. */
3095 df_uses_record (struct df_collection_rec
*collection_rec
,
3096 rtx
*loc
, enum df_ref_type ref_type
,
3097 basic_block bb
, struct df_insn_info
*insn_info
,
3107 code
= GET_CODE (x
);
3121 /* If we are clobbering a MEM, mark any registers inside the address
3123 if (MEM_P (XEXP (x
, 0)))
3124 df_uses_record (collection_rec
,
3125 &XEXP (XEXP (x
, 0), 0),
3126 DF_REF_REG_MEM_STORE
,
3130 /* If we're clobbering a REG then we have a def so ignore. */
3134 df_uses_record (collection_rec
,
3135 &XEXP (x
, 0), DF_REF_REG_MEM_LOAD
,
3136 bb
, insn_info
, flags
& DF_REF_IN_NOTE
);
3140 /* While we're here, optimize this case. */
3141 flags
|= DF_REF_PARTIAL
;
3142 /* In case the SUBREG is not of a REG, do not optimize. */
3143 if (!REG_P (SUBREG_REG (x
)))
3145 loc
= &SUBREG_REG (x
);
3146 df_uses_record (collection_rec
, loc
, ref_type
, bb
, insn_info
, flags
);
3149 /* ... Fall through ... */
3152 df_ref_record (DF_REF_REGULAR
, collection_rec
,
3153 x
, loc
, bb
, insn_info
,
3160 df_uses_record (collection_rec
,
3161 &XEXP (x
, 1), ref_type
, bb
, insn_info
, flags
);
3162 df_uses_record (collection_rec
,
3163 &XEXP (x
, 2), ref_type
, bb
, insn_info
, flags
);
3165 /* If the parameters to the zero or sign extract are
3166 constants, strip them off and recurse, otherwise there is
3167 no information that we can gain from this operation. */
3168 if (code
== ZERO_EXTRACT
)
3169 flags
|= DF_REF_ZERO_EXTRACT
;
3171 flags
|= DF_REF_SIGN_EXTRACT
;
3173 df_uses_record (collection_rec
,
3174 &XEXP (x
, 0), ref_type
, bb
, insn_info
, flags
);
3181 rtx dst
= SET_DEST (x
);
3182 gcc_assert (!(flags
& DF_REF_IN_NOTE
));
3183 df_uses_record (collection_rec
,
3184 &SET_SRC (x
), DF_REF_REG_USE
, bb
, insn_info
, flags
);
3186 switch (GET_CODE (dst
))
3189 if (df_read_modify_subreg_p (dst
))
3191 df_uses_record (collection_rec
, &SUBREG_REG (dst
),
3192 DF_REF_REG_USE
, bb
, insn_info
,
3193 flags
| DF_REF_READ_WRITE
| DF_REF_SUBREG
);
3204 df_uses_record (collection_rec
, &XEXP (dst
, 0),
3205 DF_REF_REG_MEM_STORE
, bb
, insn_info
, flags
);
3207 case STRICT_LOW_PART
:
3209 rtx
*temp
= &XEXP (dst
, 0);
3210 /* A strict_low_part uses the whole REG and not just the
3212 dst
= XEXP (dst
, 0);
3213 df_uses_record (collection_rec
,
3214 (GET_CODE (dst
) == SUBREG
) ? &SUBREG_REG (dst
) : temp
,
3215 DF_REF_REG_USE
, bb
, insn_info
,
3216 DF_REF_READ_WRITE
| DF_REF_STRICT_LOW_PART
);
3221 df_uses_record (collection_rec
, &XEXP (dst
, 1),
3222 DF_REF_REG_USE
, bb
, insn_info
, flags
);
3223 df_uses_record (collection_rec
, &XEXP (dst
, 2),
3224 DF_REF_REG_USE
, bb
, insn_info
, flags
);
3225 if (GET_CODE (XEXP (dst
,0)) == MEM
)
3226 df_uses_record (collection_rec
, &XEXP (dst
, 0),
3227 DF_REF_REG_USE
, bb
, insn_info
,
3230 df_uses_record (collection_rec
, &XEXP (dst
, 0),
3231 DF_REF_REG_USE
, bb
, insn_info
,
3232 DF_REF_READ_WRITE
| DF_REF_ZERO_EXTRACT
);
3247 case UNSPEC_VOLATILE
:
3251 /* Traditional and volatile asm instructions must be
3252 considered to use and clobber all hard registers, all
3253 pseudo-registers and all of memory. So must TRAP_IF and
3254 UNSPEC_VOLATILE operations.
3256 Consider for instance a volatile asm that changes the fpu
3257 rounding mode. An insn should not be moved across this
3258 even if it only uses pseudo-regs because it might give an
3259 incorrectly rounded result.
3261 However, flow.c's liveness computation did *not* do this,
3262 giving the reasoning as " ?!? Unfortunately, marking all
3263 hard registers as live causes massive problems for the
3264 register allocator and marking all pseudos as live creates
3265 mountains of uninitialized variable warnings."
3267 In order to maintain the status quo with regard to liveness
3268 and uses, we do what flow.c did and just mark any regs we
3269 can find in ASM_OPERANDS as used. In global asm insns are
3270 scanned and regs_asm_clobbered is filled out.
3272 For all ASM_OPERANDS, we must traverse the vector of input
3273 operands. We can not just fall through here since then we
3274 would be confused by the ASM_INPUT rtx inside ASM_OPERANDS,
3275 which do not indicate traditional asms unlike their normal
3277 if (code
== ASM_OPERANDS
)
3281 for (j
= 0; j
< ASM_OPERANDS_INPUT_LENGTH (x
); j
++)
3282 df_uses_record (collection_rec
, &ASM_OPERANDS_INPUT (x
, j
),
3283 DF_REF_REG_USE
, bb
, insn_info
, flags
);
3290 df_uses_record (collection_rec
,
3291 &PAT_VAR_LOCATION_LOC (x
),
3292 DF_REF_REG_USE
, bb
, insn_info
, flags
);
3301 gcc_assert (!DEBUG_INSN_P (insn_info
->insn
));
3302 /* Catch the def of the register being modified. */
3303 df_ref_record (DF_REF_REGULAR
, collection_rec
, XEXP (x
, 0), &XEXP (x
, 0),
3306 flags
| DF_REF_READ_WRITE
| DF_REF_PRE_POST_MODIFY
);
3308 /* ... Fall through to handle uses ... */
3314 /* Recursively scan the operands of this expression. */
3316 const char *fmt
= GET_RTX_FORMAT (code
);
3319 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3323 /* Tail recursive case: save a function call level. */
3329 df_uses_record (collection_rec
, &XEXP (x
, i
), ref_type
,
3330 bb
, insn_info
, flags
);
3332 else if (fmt
[i
] == 'E')
3335 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3336 df_uses_record (collection_rec
,
3337 &XVECEXP (x
, i
, j
), ref_type
,
3338 bb
, insn_info
, flags
);
3347 /* For all DF_REF_CONDITIONAL defs, add a corresponding uses. */
3350 df_get_conditional_uses (struct df_collection_rec
*collection_rec
)
3355 FOR_EACH_VEC_ELT (df_ref
, collection_rec
->def_vec
, ix
, ref
)
3357 if (DF_REF_FLAGS_IS_SET (ref
, DF_REF_CONDITIONAL
))
3361 use
= df_ref_create_structure (DF_REF_CLASS (ref
), collection_rec
, DF_REF_REG (ref
),
3362 DF_REF_LOC (ref
), DF_REF_BB (ref
),
3363 DF_REF_INSN_INFO (ref
), DF_REF_REG_USE
,
3364 DF_REF_FLAGS (ref
) & ~DF_REF_CONDITIONAL
);
3365 DF_REF_REGNO (use
) = DF_REF_REGNO (ref
);
3371 /* Get call's extra defs and uses (track caller-saved registers). */
3374 df_get_call_refs (struct df_collection_rec
*collection_rec
,
3376 struct df_insn_info
*insn_info
,
3380 bool is_sibling_call
;
3382 HARD_REG_SET defs_generated
;
3384 CLEAR_HARD_REG_SET (defs_generated
);
3385 df_find_hard_reg_defs (PATTERN (insn_info
->insn
), &defs_generated
);
3386 is_sibling_call
= SIBLING_CALL_P (insn_info
->insn
);
3388 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3390 if (i
== STACK_POINTER_REGNUM
)
3391 /* The stack ptr is used (honorarily) by a CALL insn. */
3392 df_ref_record (DF_REF_BASE
, collection_rec
, regno_reg_rtx
[i
],
3393 NULL
, bb
, insn_info
, DF_REF_REG_USE
,
3394 DF_REF_CALL_STACK_USAGE
| flags
);
3395 else if (global_regs
[i
])
3397 /* Calls to const functions cannot access any global registers and
3398 calls to pure functions cannot set them. All other calls may
3399 reference any of the global registers, so they are recorded as
3401 if (!RTL_CONST_CALL_P (insn_info
->insn
))
3403 df_ref_record (DF_REF_BASE
, collection_rec
, regno_reg_rtx
[i
],
3404 NULL
, bb
, insn_info
, DF_REF_REG_USE
, flags
);
3405 if (!RTL_PURE_CALL_P (insn_info
->insn
))
3406 df_ref_record (DF_REF_BASE
, collection_rec
, regno_reg_rtx
[i
],
3407 NULL
, bb
, insn_info
, DF_REF_REG_DEF
, flags
);
3410 else if (TEST_HARD_REG_BIT (regs_invalidated_by_call
, i
)
3411 /* no clobbers for regs that are the result of the call */
3412 && !TEST_HARD_REG_BIT (defs_generated
, i
)
3413 && (!is_sibling_call
3414 || !bitmap_bit_p (df
->exit_block_uses
, i
)
3415 || refers_to_regno_p (i
, i
+1,
3416 crtl
->return_rtx
, NULL
)))
3417 df_ref_record (DF_REF_BASE
, collection_rec
, regno_reg_rtx
[i
],
3418 NULL
, bb
, insn_info
, DF_REF_REG_DEF
,
3419 DF_REF_MAY_CLOBBER
| flags
);
3422 /* Record the registers used to pass arguments, and explicitly
3423 noted as clobbered. */
3424 for (note
= CALL_INSN_FUNCTION_USAGE (insn_info
->insn
); note
;
3425 note
= XEXP (note
, 1))
3427 if (GET_CODE (XEXP (note
, 0)) == USE
)
3428 df_uses_record (collection_rec
, &XEXP (XEXP (note
, 0), 0),
3429 DF_REF_REG_USE
, bb
, insn_info
, flags
);
3430 else if (GET_CODE (XEXP (note
, 0)) == CLOBBER
)
3432 if (REG_P (XEXP (XEXP (note
, 0), 0)))
3434 unsigned int regno
= REGNO (XEXP (XEXP (note
, 0), 0));
3435 if (!TEST_HARD_REG_BIT (defs_generated
, regno
))
3436 df_defs_record (collection_rec
, XEXP (note
, 0), bb
,
3440 df_uses_record (collection_rec
, &XEXP (note
, 0),
3441 DF_REF_REG_USE
, bb
, insn_info
, flags
);
3448 /* Collect all refs in the INSN. This function is free of any
3449 side-effect - it will create and return a lists of df_ref's in the
3450 COLLECTION_REC without putting those refs into existing ref chains
3454 df_insn_refs_collect (struct df_collection_rec
*collection_rec
,
3455 basic_block bb
, struct df_insn_info
*insn_info
)
3458 bool is_cond_exec
= (GET_CODE (PATTERN (insn_info
->insn
)) == COND_EXEC
);
3460 /* Clear out the collection record. */
3461 VEC_truncate (df_ref
, collection_rec
->def_vec
, 0);
3462 VEC_truncate (df_ref
, collection_rec
->use_vec
, 0);
3463 VEC_truncate (df_ref
, collection_rec
->eq_use_vec
, 0);
3464 VEC_truncate (df_mw_hardreg_ptr
, collection_rec
->mw_vec
, 0);
3466 /* Process REG_EQUIV/REG_EQUAL notes. */
3467 for (note
= REG_NOTES (insn_info
->insn
); note
;
3468 note
= XEXP (note
, 1))
3470 switch (REG_NOTE_KIND (note
))
3474 df_uses_record (collection_rec
,
3475 &XEXP (note
, 0), DF_REF_REG_USE
,
3476 bb
, insn_info
, DF_REF_IN_NOTE
);
3478 case REG_NON_LOCAL_GOTO
:
3479 /* The frame ptr is used by a non-local goto. */
3480 df_ref_record (DF_REF_BASE
, collection_rec
,
3481 regno_reg_rtx
[FRAME_POINTER_REGNUM
],
3482 NULL
, bb
, insn_info
,
3484 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
3485 df_ref_record (DF_REF_BASE
, collection_rec
,
3486 regno_reg_rtx
[HARD_FRAME_POINTER_REGNUM
],
3487 NULL
, bb
, insn_info
,
3496 /* For CALL_INSNs, first record DF_REF_BASE register defs, as well as
3497 uses from CALL_INSN_FUNCTION_USAGE. */
3498 if (CALL_P (insn_info
->insn
))
3499 df_get_call_refs (collection_rec
, bb
, insn_info
,
3500 (is_cond_exec
) ? DF_REF_CONDITIONAL
: 0);
3502 /* Record other defs. These should be mostly for DF_REF_REGULAR, so
3503 that a qsort on the defs is unnecessary in most cases. */
3504 df_defs_record (collection_rec
,
3505 PATTERN (insn_info
->insn
), bb
, insn_info
, 0);
3507 /* Record the register uses. */
3508 df_uses_record (collection_rec
,
3509 &PATTERN (insn_info
->insn
), DF_REF_REG_USE
, bb
, insn_info
, 0);
3511 /* DF_REF_CONDITIONAL needs corresponding USES. */
3513 df_get_conditional_uses (collection_rec
);
3515 df_canonize_collection_rec (collection_rec
);
3518 /* Recompute the luids for the insns in BB. */
3521 df_recompute_luids (basic_block bb
)
3526 df_grow_insn_info ();
3528 /* Scan the block an insn at a time from beginning to end. */
3529 FOR_BB_INSNS (bb
, insn
)
3531 struct df_insn_info
*insn_info
= DF_INSN_INFO_GET (insn
);
3532 /* Inserting labels does not always trigger the incremental
3536 gcc_assert (!INSN_P (insn
));
3537 insn_info
= df_insn_create_insn_record (insn
);
3540 DF_INSN_INFO_LUID (insn_info
) = luid
;
3547 /* Collect all artificial refs at the block level for BB and add them
3548 to COLLECTION_REC. */
3551 df_bb_refs_collect (struct df_collection_rec
*collection_rec
, basic_block bb
)
3553 VEC_truncate (df_ref
, collection_rec
->def_vec
, 0);
3554 VEC_truncate (df_ref
, collection_rec
->use_vec
, 0);
3555 VEC_truncate (df_ref
, collection_rec
->eq_use_vec
, 0);
3556 VEC_truncate (df_mw_hardreg_ptr
, collection_rec
->mw_vec
, 0);
3558 if (bb
->index
== ENTRY_BLOCK
)
3560 df_entry_block_defs_collect (collection_rec
, df
->entry_block_defs
);
3563 else if (bb
->index
== EXIT_BLOCK
)
3565 df_exit_block_uses_collect (collection_rec
, df
->exit_block_uses
);
3569 #ifdef EH_RETURN_DATA_REGNO
3570 if (bb_has_eh_pred (bb
))
3573 /* Mark the registers that will contain data for the handler. */
3576 unsigned regno
= EH_RETURN_DATA_REGNO (i
);
3577 if (regno
== INVALID_REGNUM
)
3579 df_ref_record (DF_REF_ARTIFICIAL
, collection_rec
, regno_reg_rtx
[regno
], NULL
,
3580 bb
, NULL
, DF_REF_REG_DEF
, DF_REF_AT_TOP
);
3585 /* Add the hard_frame_pointer if this block is the target of a
3587 if (bb
->flags
& BB_NON_LOCAL_GOTO_TARGET
)
3588 df_ref_record (DF_REF_ARTIFICIAL
, collection_rec
, hard_frame_pointer_rtx
, NULL
,
3589 bb
, NULL
, DF_REF_REG_DEF
, DF_REF_AT_TOP
);
3591 /* Add the artificial uses. */
3592 if (bb
->index
>= NUM_FIXED_BLOCKS
)
3596 bitmap au
= bb_has_eh_pred (bb
)
3597 ? &df
->eh_block_artificial_uses
3598 : &df
->regular_block_artificial_uses
;
3600 EXECUTE_IF_SET_IN_BITMAP (au
, 0, regno
, bi
)
3602 df_ref_record (DF_REF_ARTIFICIAL
, collection_rec
, regno_reg_rtx
[regno
], NULL
,
3603 bb
, NULL
, DF_REF_REG_USE
, 0);
3607 df_canonize_collection_rec (collection_rec
);
3611 /* Record all the refs within the basic block BB_INDEX and scan the instructions if SCAN_INSNS. */
3614 df_bb_refs_record (int bb_index
, bool scan_insns
)
3616 basic_block bb
= BASIC_BLOCK (bb_index
);
3619 struct df_collection_rec collection_rec
;
3624 df_grow_bb_info (df_scan
);
3625 collection_rec
.def_vec
= VEC_alloc (df_ref
, stack
, 128);
3626 collection_rec
.use_vec
= VEC_alloc (df_ref
, stack
, 32);
3627 collection_rec
.eq_use_vec
= VEC_alloc (df_ref
, stack
, 32);
3628 collection_rec
.mw_vec
= VEC_alloc (df_mw_hardreg_ptr
, stack
, 32);
3631 /* Scan the block an insn at a time from beginning to end. */
3632 FOR_BB_INSNS (bb
, insn
)
3634 struct df_insn_info
*insn_info
= DF_INSN_INFO_GET (insn
);
3635 gcc_assert (!insn_info
);
3637 insn_info
= df_insn_create_insn_record (insn
);
3640 /* Record refs within INSN. */
3641 DF_INSN_INFO_LUID (insn_info
) = luid
++;
3642 df_insn_refs_collect (&collection_rec
, bb
, DF_INSN_INFO_GET (insn
));
3643 df_refs_add_to_chains (&collection_rec
, bb
, insn
);
3645 DF_INSN_INFO_LUID (insn_info
) = luid
;
3648 /* Other block level artificial refs */
3649 df_bb_refs_collect (&collection_rec
, bb
);
3650 df_refs_add_to_chains (&collection_rec
, bb
, NULL
);
3652 VEC_free (df_ref
, stack
, collection_rec
.def_vec
);
3653 VEC_free (df_ref
, stack
, collection_rec
.use_vec
);
3654 VEC_free (df_ref
, stack
, collection_rec
.eq_use_vec
);
3655 VEC_free (df_mw_hardreg_ptr
, stack
, collection_rec
.mw_vec
);
3657 /* Now that the block has been processed, set the block as dirty so
3658 LR and LIVE will get it processed. */
3659 df_set_bb_dirty (bb
);
3663 /* Get the artificial use set for a regular (i.e. non-exit/non-entry)
3667 df_get_regular_block_artificial_uses (bitmap regular_block_artificial_uses
)
3673 bitmap_clear (regular_block_artificial_uses
);
3675 if (reload_completed
)
3677 if (frame_pointer_needed
)
3678 bitmap_set_bit (regular_block_artificial_uses
, HARD_FRAME_POINTER_REGNUM
);
3681 /* Before reload, there are a few registers that must be forced
3682 live everywhere -- which might not already be the case for
3683 blocks within infinite loops. */
3685 unsigned int picreg
= PIC_OFFSET_TABLE_REGNUM
;
3687 /* Any reference to any pseudo before reload is a potential
3688 reference of the frame pointer. */
3689 bitmap_set_bit (regular_block_artificial_uses
, FRAME_POINTER_REGNUM
);
3691 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
3692 bitmap_set_bit (regular_block_artificial_uses
, HARD_FRAME_POINTER_REGNUM
);
3695 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3696 /* Pseudos with argument area equivalences may require
3697 reloading via the argument pointer. */
3698 if (fixed_regs
[ARG_POINTER_REGNUM
])
3699 bitmap_set_bit (regular_block_artificial_uses
, ARG_POINTER_REGNUM
);
3702 /* Any constant, or pseudo with constant equivalences, may
3703 require reloading from memory using the pic register. */
3704 if (picreg
!= INVALID_REGNUM
3705 && fixed_regs
[picreg
])
3706 bitmap_set_bit (regular_block_artificial_uses
, picreg
);
3708 /* The all-important stack pointer must always be live. */
3709 bitmap_set_bit (regular_block_artificial_uses
, STACK_POINTER_REGNUM
);
3712 /* EH_USES registers are used:
3713 1) at all insns that might throw (calls or with -fnon-call-exceptions
3716 3) to support backtraces and/or debugging, anywhere between their
3717 initialization and where they the saved registers are restored
3718 from them, including the cases where we don't reach the epilogue
3719 (noreturn call or infinite loop). */
3720 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3722 bitmap_set_bit (regular_block_artificial_uses
, i
);
3727 /* Get the artificial use set for an eh block. */
3730 df_get_eh_block_artificial_uses (bitmap eh_block_artificial_uses
)
3732 bitmap_clear (eh_block_artificial_uses
);
3734 /* The following code (down through the arg_pointer setting APPEARS
3735 to be necessary because there is nothing that actually
3736 describes what the exception handling code may actually need
3738 if (reload_completed
)
3740 if (frame_pointer_needed
)
3742 bitmap_set_bit (eh_block_artificial_uses
, FRAME_POINTER_REGNUM
);
3743 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
3744 bitmap_set_bit (eh_block_artificial_uses
, HARD_FRAME_POINTER_REGNUM
);
3747 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3748 if (fixed_regs
[ARG_POINTER_REGNUM
])
3749 bitmap_set_bit (eh_block_artificial_uses
, ARG_POINTER_REGNUM
);
3756 /*----------------------------------------------------------------------------
3757 Specialized hard register scanning functions.
3758 ----------------------------------------------------------------------------*/
3761 /* Mark a register in SET. Hard registers in large modes get all
3762 of their component registers set as well. */
3765 df_mark_reg (rtx reg
, void *vset
)
3767 bitmap set
= (bitmap
) vset
;
3768 int regno
= REGNO (reg
);
3770 gcc_assert (GET_MODE (reg
) != BLKmode
);
3772 if (regno
< FIRST_PSEUDO_REGISTER
)
3774 int n
= hard_regno_nregs
[regno
][GET_MODE (reg
)];
3775 bitmap_set_range (set
, regno
, n
);
3778 bitmap_set_bit (set
, regno
);
3782 /* Set the bit for regs that are considered being defined at the entry. */
3785 df_get_entry_block_def_set (bitmap entry_block_defs
)
3790 bitmap_clear (entry_block_defs
);
3792 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3793 if (FUNCTION_ARG_REGNO_P (i
))
3794 bitmap_set_bit (entry_block_defs
, INCOMING_REGNO (i
));
3796 /* The always important stack pointer. */
3797 bitmap_set_bit (entry_block_defs
, STACK_POINTER_REGNUM
);
3799 /* Once the prologue has been generated, all of these registers
3800 should just show up in the first regular block. */
3801 if (HAVE_prologue
&& epilogue_completed
)
3803 /* Defs for the callee saved registers are inserted so that the
3804 pushes have some defining location. */
3805 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3806 if ((call_used_regs
[i
] == 0) && (df_regs_ever_live_p (i
)))
3807 bitmap_set_bit (entry_block_defs
, i
);
3810 r
= targetm
.calls
.struct_value_rtx (current_function_decl
, true);
3812 bitmap_set_bit (entry_block_defs
, REGNO (r
));
3814 /* If the function has an incoming STATIC_CHAIN, it has to show up
3815 in the entry def set. */
3816 r
= targetm
.calls
.static_chain (current_function_decl
, true);
3818 bitmap_set_bit (entry_block_defs
, REGNO (r
));
3820 if ((!reload_completed
) || frame_pointer_needed
)
3822 /* Any reference to any pseudo before reload is a potential
3823 reference of the frame pointer. */
3824 bitmap_set_bit (entry_block_defs
, FRAME_POINTER_REGNUM
);
3825 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
3826 /* If they are different, also mark the hard frame pointer as live. */
3827 if (!LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM
))
3828 bitmap_set_bit (entry_block_defs
, HARD_FRAME_POINTER_REGNUM
);
3832 /* These registers are live everywhere. */
3833 if (!reload_completed
)
3835 #ifdef PIC_OFFSET_TABLE_REGNUM
3836 unsigned int picreg
= PIC_OFFSET_TABLE_REGNUM
;
3839 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3840 /* Pseudos with argument area equivalences may require
3841 reloading via the argument pointer. */
3842 if (fixed_regs
[ARG_POINTER_REGNUM
])
3843 bitmap_set_bit (entry_block_defs
, ARG_POINTER_REGNUM
);
3846 #ifdef PIC_OFFSET_TABLE_REGNUM
3847 /* Any constant, or pseudo with constant equivalences, may
3848 require reloading from memory using the pic register. */
3849 if (picreg
!= INVALID_REGNUM
3850 && fixed_regs
[picreg
])
3851 bitmap_set_bit (entry_block_defs
, picreg
);
3855 #ifdef INCOMING_RETURN_ADDR_RTX
3856 if (REG_P (INCOMING_RETURN_ADDR_RTX
))
3857 bitmap_set_bit (entry_block_defs
, REGNO (INCOMING_RETURN_ADDR_RTX
));
3860 targetm
.extra_live_on_entry (entry_block_defs
);
3864 /* Return the (conservative) set of hard registers that are defined on
3865 entry to the function.
3866 It uses df->entry_block_defs to determine which register
3867 reference to include. */
3870 df_entry_block_defs_collect (struct df_collection_rec
*collection_rec
,
3871 bitmap entry_block_defs
)
3876 EXECUTE_IF_SET_IN_BITMAP (entry_block_defs
, 0, i
, bi
)
3878 df_ref_record (DF_REF_ARTIFICIAL
, collection_rec
, regno_reg_rtx
[i
], NULL
,
3879 ENTRY_BLOCK_PTR
, NULL
, DF_REF_REG_DEF
, 0);
3882 df_canonize_collection_rec (collection_rec
);
3886 /* Record the (conservative) set of hard registers that are defined on
3887 entry to the function. */
3890 df_record_entry_block_defs (bitmap entry_block_defs
)
3892 struct df_collection_rec collection_rec
;
3893 memset (&collection_rec
, 0, sizeof (struct df_collection_rec
));
3894 collection_rec
.def_vec
= VEC_alloc (df_ref
, stack
, FIRST_PSEUDO_REGISTER
);
3895 df_entry_block_defs_collect (&collection_rec
, entry_block_defs
);
3897 /* Process bb_refs chain */
3898 df_refs_add_to_chains (&collection_rec
, BASIC_BLOCK (ENTRY_BLOCK
), NULL
);
3899 VEC_free (df_ref
, stack
, collection_rec
.def_vec
);
3903 /* Update the defs in the entry block. */
3906 df_update_entry_block_defs (void)
3909 bool changed
= false;
3911 bitmap_initialize (&refs
, &df_bitmap_obstack
);
3912 df_get_entry_block_def_set (&refs
);
3913 if (df
->entry_block_defs
)
3915 if (!bitmap_equal_p (df
->entry_block_defs
, &refs
))
3917 struct df_scan_bb_info
*bb_info
= df_scan_get_bb_info (ENTRY_BLOCK
);
3918 df_ref_chain_delete_du_chain (bb_info
->artificial_defs
);
3919 df_ref_chain_delete (bb_info
->artificial_defs
);
3920 bb_info
->artificial_defs
= NULL
;
3926 struct df_scan_problem_data
*problem_data
3927 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
3929 df
->entry_block_defs
= BITMAP_ALLOC (&problem_data
->reg_bitmaps
);
3935 df_record_entry_block_defs (&refs
);
3936 bitmap_copy (df
->entry_block_defs
, &refs
);
3937 df_set_bb_dirty (BASIC_BLOCK (ENTRY_BLOCK
));
3939 bitmap_clear (&refs
);
3943 /* Set the bit for regs that are considered being used at the exit. */
3946 df_get_exit_block_use_set (bitmap exit_block_uses
)
3949 unsigned int picreg
= PIC_OFFSET_TABLE_REGNUM
;
3951 bitmap_clear (exit_block_uses
);
3953 /* Stack pointer is always live at the exit. */
3954 bitmap_set_bit (exit_block_uses
, STACK_POINTER_REGNUM
);
3956 /* Mark the frame pointer if needed at the end of the function.
3957 If we end up eliminating it, it will be removed from the live
3958 list of each basic block by reload. */
3960 if ((!reload_completed
) || frame_pointer_needed
)
3962 bitmap_set_bit (exit_block_uses
, FRAME_POINTER_REGNUM
);
3963 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
3964 /* If they are different, also mark the hard frame pointer as live. */
3965 if (!LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM
))
3966 bitmap_set_bit (exit_block_uses
, HARD_FRAME_POINTER_REGNUM
);
3970 /* Many architectures have a GP register even without flag_pic.
3971 Assume the pic register is not in use, or will be handled by
3972 other means, if it is not fixed. */
3973 if (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
3974 && picreg
!= INVALID_REGNUM
3975 && fixed_regs
[picreg
])
3976 bitmap_set_bit (exit_block_uses
, picreg
);
3978 /* Mark all global registers, and all registers used by the
3979 epilogue as being live at the end of the function since they
3980 may be referenced by our caller. */
3981 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3982 if (global_regs
[i
] || EPILOGUE_USES (i
))
3983 bitmap_set_bit (exit_block_uses
, i
);
3985 if (HAVE_epilogue
&& epilogue_completed
)
3987 /* Mark all call-saved registers that we actually used. */
3988 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
3989 if (df_regs_ever_live_p (i
) && !LOCAL_REGNO (i
)
3990 && !TEST_HARD_REG_BIT (regs_invalidated_by_call
, i
))
3991 bitmap_set_bit (exit_block_uses
, i
);
3994 #ifdef EH_RETURN_DATA_REGNO
3995 /* Mark the registers that will contain data for the handler. */
3996 if (reload_completed
&& crtl
->calls_eh_return
)
3999 unsigned regno
= EH_RETURN_DATA_REGNO (i
);
4000 if (regno
== INVALID_REGNUM
)
4002 bitmap_set_bit (exit_block_uses
, regno
);
4006 #ifdef EH_RETURN_STACKADJ_RTX
4007 if ((!HAVE_epilogue
|| ! epilogue_completed
)
4008 && crtl
->calls_eh_return
)
4010 rtx tmp
= EH_RETURN_STACKADJ_RTX
;
4011 if (tmp
&& REG_P (tmp
))
4012 df_mark_reg (tmp
, exit_block_uses
);
4016 #ifdef EH_RETURN_HANDLER_RTX
4017 if ((!HAVE_epilogue
|| ! epilogue_completed
)
4018 && crtl
->calls_eh_return
)
4020 rtx tmp
= EH_RETURN_HANDLER_RTX
;
4021 if (tmp
&& REG_P (tmp
))
4022 df_mark_reg (tmp
, exit_block_uses
);
4026 /* Mark function return value. */
4027 diddle_return_value (df_mark_reg
, (void*) exit_block_uses
);
4031 /* Return the refs of hard registers that are used in the exit block.
4032 It uses df->exit_block_uses to determine register to include. */
4035 df_exit_block_uses_collect (struct df_collection_rec
*collection_rec
, bitmap exit_block_uses
)
4040 EXECUTE_IF_SET_IN_BITMAP (exit_block_uses
, 0, i
, bi
)
4041 df_ref_record (DF_REF_ARTIFICIAL
, collection_rec
, regno_reg_rtx
[i
], NULL
,
4042 EXIT_BLOCK_PTR
, NULL
, DF_REF_REG_USE
, 0);
4044 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4045 /* It is deliberate that this is not put in the exit block uses but
4046 I do not know why. */
4047 if (reload_completed
4048 && !bitmap_bit_p (exit_block_uses
, ARG_POINTER_REGNUM
)
4049 && bb_has_eh_pred (EXIT_BLOCK_PTR
)
4050 && fixed_regs
[ARG_POINTER_REGNUM
])
4051 df_ref_record (DF_REF_ARTIFICIAL
, collection_rec
, regno_reg_rtx
[ARG_POINTER_REGNUM
], NULL
,
4052 EXIT_BLOCK_PTR
, NULL
, DF_REF_REG_USE
, 0);
4055 df_canonize_collection_rec (collection_rec
);
4059 /* Record the set of hard registers that are used in the exit block.
4060 It uses df->exit_block_uses to determine which bit to include. */
4063 df_record_exit_block_uses (bitmap exit_block_uses
)
4065 struct df_collection_rec collection_rec
;
4066 memset (&collection_rec
, 0, sizeof (struct df_collection_rec
));
4067 collection_rec
.use_vec
= VEC_alloc (df_ref
, stack
, FIRST_PSEUDO_REGISTER
);
4069 df_exit_block_uses_collect (&collection_rec
, exit_block_uses
);
4071 /* Process bb_refs chain */
4072 df_refs_add_to_chains (&collection_rec
, BASIC_BLOCK (EXIT_BLOCK
), NULL
);
4073 VEC_free (df_ref
, stack
, collection_rec
.use_vec
);
4077 /* Update the uses in the exit block. */
4080 df_update_exit_block_uses (void)
4083 bool changed
= false;
4085 bitmap_initialize (&refs
, &df_bitmap_obstack
);
4086 df_get_exit_block_use_set (&refs
);
4087 if (df
->exit_block_uses
)
4089 if (!bitmap_equal_p (df
->exit_block_uses
, &refs
))
4091 struct df_scan_bb_info
*bb_info
= df_scan_get_bb_info (EXIT_BLOCK
);
4092 df_ref_chain_delete_du_chain (bb_info
->artificial_uses
);
4093 df_ref_chain_delete (bb_info
->artificial_uses
);
4094 bb_info
->artificial_uses
= NULL
;
4100 struct df_scan_problem_data
*problem_data
4101 = (struct df_scan_problem_data
*) df_scan
->problem_data
;
4103 df
->exit_block_uses
= BITMAP_ALLOC (&problem_data
->reg_bitmaps
);
4109 df_record_exit_block_uses (&refs
);
4110 bitmap_copy (df
->exit_block_uses
,& refs
);
4111 df_set_bb_dirty (BASIC_BLOCK (EXIT_BLOCK
));
4113 bitmap_clear (&refs
);
4116 static bool initialized
= false;
4119 /* Initialize some platform specific structures. */
4122 df_hard_reg_init (void)
4124 #ifdef ELIMINABLE_REGS
4126 static const struct {const int from
, to
; } eliminables
[] = ELIMINABLE_REGS
;
4131 /* Record which registers will be eliminated. We use this in
4133 CLEAR_HARD_REG_SET (elim_reg_set
);
4135 #ifdef ELIMINABLE_REGS
4136 for (i
= 0; i
< (int) ARRAY_SIZE (eliminables
); i
++)
4137 SET_HARD_REG_BIT (elim_reg_set
, eliminables
[i
].from
);
4139 SET_HARD_REG_BIT (elim_reg_set
, FRAME_POINTER_REGNUM
);
4146 /* Recompute the parts of scanning that are based on regs_ever_live
4147 because something changed in that array. */
4150 df_update_entry_exit_and_calls (void)
4154 df_update_entry_block_defs ();
4155 df_update_exit_block_uses ();
4157 /* The call insns need to be rescanned because there may be changes
4158 in the set of registers clobbered across the call. */
4162 FOR_BB_INSNS (bb
, insn
)
4164 if (INSN_P (insn
) && CALL_P (insn
))
4165 df_insn_rescan (insn
);
4171 /* Return true if hard REG is actually used in the some instruction.
4172 There are a fair number of conditions that affect the setting of
4173 this array. See the comment in df.h for df->hard_regs_live_count
4174 for the conditions that this array is set. */
4177 df_hard_reg_used_p (unsigned int reg
)
4179 return df
->hard_regs_live_count
[reg
] != 0;
4183 /* A count of the number of times REG is actually used in the some
4184 instruction. There are a fair number of conditions that affect the
4185 setting of this array. See the comment in df.h for
4186 df->hard_regs_live_count for the conditions that this array is
4191 df_hard_reg_used_count (unsigned int reg
)
4193 return df
->hard_regs_live_count
[reg
];
4197 /* Get the value of regs_ever_live[REGNO]. */
4200 df_regs_ever_live_p (unsigned int regno
)
4202 return regs_ever_live
[regno
];
4206 /* Set regs_ever_live[REGNO] to VALUE. If this cause regs_ever_live
4207 to change, schedule that change for the next update. */
4210 df_set_regs_ever_live (unsigned int regno
, bool value
)
4212 if (regs_ever_live
[regno
] == value
)
4215 regs_ever_live
[regno
] = value
;
4217 df
->redo_entry_and_exit
= true;
4221 /* Compute "regs_ever_live" information from the underlying df
4222 information. Set the vector to all false if RESET. */
4225 df_compute_regs_ever_live (bool reset
)
4228 bool changed
= df
->redo_entry_and_exit
;
4231 memset (regs_ever_live
, 0, sizeof (regs_ever_live
));
4233 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4234 if ((!regs_ever_live
[i
]) && df_hard_reg_used_p (i
))
4236 regs_ever_live
[i
] = true;
4240 df_update_entry_exit_and_calls ();
4241 df
->redo_entry_and_exit
= false;
4245 /*----------------------------------------------------------------------------
4246 Dataflow ref information verification functions.
4248 df_reg_chain_mark (refs, regno, is_def, is_eq_use)
4249 df_reg_chain_verify_unmarked (refs)
4250 df_refs_verify (VEC(stack,df_ref)*, ref*, bool)
4251 df_mws_verify (mw*, mw*, bool)
4252 df_insn_refs_verify (collection_rec, bb, insn, bool)
4253 df_bb_refs_verify (bb, refs, bool)
4255 df_exit_block_bitmap_verify (bool)
4256 df_entry_block_bitmap_verify (bool)
4258 ----------------------------------------------------------------------------*/
4261 /* Mark all refs in the reg chain. Verify that all of the registers
4262 are in the correct chain. */
4265 df_reg_chain_mark (df_ref refs
, unsigned int regno
,
4266 bool is_def
, bool is_eq_use
)
4268 unsigned int count
= 0;
4270 for (ref
= refs
; ref
; ref
= DF_REF_NEXT_REG (ref
))
4272 gcc_assert (!DF_REF_IS_REG_MARKED (ref
));
4274 /* If there are no def-use or use-def chains, make sure that all
4275 of the chains are clear. */
4277 gcc_assert (!DF_REF_CHAIN (ref
));
4279 /* Check to make sure the ref is in the correct chain. */
4280 gcc_assert (DF_REF_REGNO (ref
) == regno
);
4282 gcc_assert (DF_REF_REG_DEF_P (ref
));
4284 gcc_assert (!DF_REF_REG_DEF_P (ref
));
4287 gcc_assert ((DF_REF_FLAGS (ref
) & DF_REF_IN_NOTE
));
4289 gcc_assert ((DF_REF_FLAGS (ref
) & DF_REF_IN_NOTE
) == 0);
4291 if (DF_REF_NEXT_REG (ref
))
4292 gcc_assert (DF_REF_PREV_REG (DF_REF_NEXT_REG (ref
)) == ref
);
4294 DF_REF_REG_MARK (ref
);
4300 /* Verify that all of the registers in the chain are unmarked. */
4303 df_reg_chain_verify_unmarked (df_ref refs
)
4306 for (ref
= refs
; ref
; ref
= DF_REF_NEXT_REG (ref
))
4307 gcc_assert (!DF_REF_IS_REG_MARKED (ref
));
4311 /* Verify that NEW_REC and OLD_REC have exactly the same members. */
4314 df_refs_verify (VEC(df_ref
,stack
) *new_rec
, df_ref
*old_rec
,
4320 FOR_EACH_VEC_ELT (df_ref
, new_rec
, ix
, new_ref
)
4322 if (*old_rec
== NULL
|| !df_ref_equal_p (new_ref
, *old_rec
))
4330 /* Abort if fail is called from the function level verifier. If
4331 that is the context, mark this reg as being seem. */
4334 gcc_assert (DF_REF_IS_REG_MARKED (*old_rec
));
4335 DF_REF_REG_UNMARK (*old_rec
);
4342 gcc_assert (*old_rec
== NULL
);
4344 return *old_rec
== NULL
;
4349 /* Verify that NEW_REC and OLD_REC have exactly the same members. */
4352 df_mws_verify (VEC(df_mw_hardreg_ptr
,stack
) *new_rec
,
4353 struct df_mw_hardreg
**old_rec
,
4357 struct df_mw_hardreg
*new_reg
;
4359 FOR_EACH_VEC_ELT (df_mw_hardreg_ptr
, new_rec
, ix
, new_reg
)
4361 if (*old_rec
== NULL
|| !df_mw_equal_p (new_reg
, *old_rec
))
4372 gcc_assert (*old_rec
== NULL
);
4374 return *old_rec
== NULL
;
4379 /* Return true if the existing insn refs information is complete and
4380 correct. Otherwise (i.e. if there's any missing or extra refs),
4381 return the correct df_ref chain in REFS_RETURN.
4383 If ABORT_IF_FAIL, leave the refs that are verified (already in the
4384 ref chain) as DF_REF_MARKED(). If it's false, then it's a per-insn
4385 verification mode instead of the whole function, so unmark
4388 If ABORT_IF_FAIL is set, this function never returns false. */
4391 df_insn_refs_verify (struct df_collection_rec
*collection_rec
,
4396 bool ret1
, ret2
, ret3
, ret4
;
4397 unsigned int uid
= INSN_UID (insn
);
4398 struct df_insn_info
*insn_info
= DF_INSN_INFO_GET (insn
);
4400 df_insn_refs_collect (collection_rec
, bb
, insn_info
);
4402 if (!DF_INSN_UID_DEFS (uid
))
4404 /* The insn_rec was created but it was never filled out. */
4411 /* Unfortunately we cannot opt out early if one of these is not
4412 right because the marks will not get cleared. */
4413 ret1
= df_refs_verify (collection_rec
->def_vec
, DF_INSN_UID_DEFS (uid
),
4415 ret2
= df_refs_verify (collection_rec
->use_vec
, DF_INSN_UID_USES (uid
),
4417 ret3
= df_refs_verify (collection_rec
->eq_use_vec
, DF_INSN_UID_EQ_USES (uid
),
4419 ret4
= df_mws_verify (collection_rec
->mw_vec
, DF_INSN_UID_MWS (uid
),
4421 return (ret1
&& ret2
&& ret3
&& ret4
);
4425 /* Return true if all refs in the basic block are correct and complete.
4426 Due to df_ref_chain_verify, it will cause all refs
4427 that are verified to have DF_REF_MARK bit set. */
4430 df_bb_verify (basic_block bb
)
4433 struct df_scan_bb_info
*bb_info
= df_scan_get_bb_info (bb
->index
);
4434 struct df_collection_rec collection_rec
;
4436 memset (&collection_rec
, 0, sizeof (struct df_collection_rec
));
4437 collection_rec
.def_vec
= VEC_alloc (df_ref
, stack
, 128);
4438 collection_rec
.use_vec
= VEC_alloc (df_ref
, stack
, 32);
4439 collection_rec
.eq_use_vec
= VEC_alloc (df_ref
, stack
, 32);
4440 collection_rec
.mw_vec
= VEC_alloc (df_mw_hardreg_ptr
, stack
, 32);
4442 gcc_assert (bb_info
);
4444 /* Scan the block, one insn at a time, from beginning to end. */
4445 FOR_BB_INSNS_REVERSE (bb
, insn
)
4449 df_insn_refs_verify (&collection_rec
, bb
, insn
, true);
4450 df_free_collection_rec (&collection_rec
);
4453 /* Do the artificial defs and uses. */
4454 df_bb_refs_collect (&collection_rec
, bb
);
4455 df_refs_verify (collection_rec
.def_vec
, df_get_artificial_defs (bb
->index
), true);
4456 df_refs_verify (collection_rec
.use_vec
, df_get_artificial_uses (bb
->index
), true);
4457 df_free_collection_rec (&collection_rec
);
4463 /* Returns true if the entry block has correct and complete df_ref set.
4464 If not it either aborts if ABORT_IF_FAIL is true or returns false. */
4467 df_entry_block_bitmap_verify (bool abort_if_fail
)
4469 bitmap_head entry_block_defs
;
4472 bitmap_initialize (&entry_block_defs
, &df_bitmap_obstack
);
4473 df_get_entry_block_def_set (&entry_block_defs
);
4475 is_eq
= bitmap_equal_p (&entry_block_defs
, df
->entry_block_defs
);
4477 if (!is_eq
&& abort_if_fail
)
4479 fprintf (stderr
, "entry_block_defs = ");
4480 df_print_regset (stderr
, &entry_block_defs
);
4481 fprintf (stderr
, "df->entry_block_defs = ");
4482 df_print_regset (stderr
, df
->entry_block_defs
);
4486 bitmap_clear (&entry_block_defs
);
4492 /* Returns true if the exit block has correct and complete df_ref set.
4493 If not it either aborts if ABORT_IF_FAIL is true or returns false. */
4496 df_exit_block_bitmap_verify (bool abort_if_fail
)
4498 bitmap_head exit_block_uses
;
4501 bitmap_initialize (&exit_block_uses
, &df_bitmap_obstack
);
4502 df_get_exit_block_use_set (&exit_block_uses
);
4504 is_eq
= bitmap_equal_p (&exit_block_uses
, df
->exit_block_uses
);
4506 if (!is_eq
&& abort_if_fail
)
4508 fprintf (stderr
, "exit_block_uses = ");
4509 df_print_regset (stderr
, &exit_block_uses
);
4510 fprintf (stderr
, "df->exit_block_uses = ");
4511 df_print_regset (stderr
, df
->exit_block_uses
);
4515 bitmap_clear (&exit_block_uses
);
4521 /* Return true if df_ref information for all insns in all blocks are
4522 correct and complete. */
4525 df_scan_verify (void)
4529 bitmap_head regular_block_artificial_uses
;
4530 bitmap_head eh_block_artificial_uses
;
4535 /* Verification is a 4 step process. */
4537 /* (1) All of the refs are marked by going through the reg chains. */
4538 for (i
= 0; i
< DF_REG_SIZE (df
); i
++)
4540 gcc_assert (df_reg_chain_mark (DF_REG_DEF_CHAIN (i
), i
, true, false)
4541 == DF_REG_DEF_COUNT(i
));
4542 gcc_assert (df_reg_chain_mark (DF_REG_USE_CHAIN (i
), i
, false, false)
4543 == DF_REG_USE_COUNT(i
));
4544 gcc_assert (df_reg_chain_mark (DF_REG_EQ_USE_CHAIN (i
), i
, false, true)
4545 == DF_REG_EQ_USE_COUNT(i
));
4548 /* (2) There are various bitmaps whose value may change over the
4549 course of the compilation. This step recomputes them to make
4550 sure that they have not slipped out of date. */
4551 bitmap_initialize (®ular_block_artificial_uses
, &df_bitmap_obstack
);
4552 bitmap_initialize (&eh_block_artificial_uses
, &df_bitmap_obstack
);
4554 df_get_regular_block_artificial_uses (®ular_block_artificial_uses
);
4555 df_get_eh_block_artificial_uses (&eh_block_artificial_uses
);
4557 bitmap_ior_into (&eh_block_artificial_uses
,
4558 ®ular_block_artificial_uses
);
4560 /* Check artificial_uses bitmaps didn't change. */
4561 gcc_assert (bitmap_equal_p (®ular_block_artificial_uses
,
4562 &df
->regular_block_artificial_uses
));
4563 gcc_assert (bitmap_equal_p (&eh_block_artificial_uses
,
4564 &df
->eh_block_artificial_uses
));
4566 bitmap_clear (®ular_block_artificial_uses
);
4567 bitmap_clear (&eh_block_artificial_uses
);
4569 /* Verify entry block and exit block. These only verify the bitmaps,
4570 the refs are verified in df_bb_verify. */
4571 df_entry_block_bitmap_verify (true);
4572 df_exit_block_bitmap_verify (true);
4574 /* (3) All of the insns in all of the blocks are traversed and the
4575 marks are cleared both in the artificial refs attached to the
4576 blocks and the real refs inside the insns. It is a failure to
4577 clear a mark that has not been set as this means that the ref in
4578 the block or insn was not in the reg chain. */
4583 /* (4) See if all reg chains are traversed a second time. This time
4584 a check is made that the marks are clear. A set mark would be a
4585 from a reg that is not in any insn or basic block. */
4587 for (i
= 0; i
< DF_REG_SIZE (df
); i
++)
4589 df_reg_chain_verify_unmarked (DF_REG_DEF_CHAIN (i
));
4590 df_reg_chain_verify_unmarked (DF_REG_USE_CHAIN (i
));
4591 df_reg_chain_verify_unmarked (DF_REG_EQ_USE_CHAIN (i
));