]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/df-scan.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* module.c (mio_f2k_derived): Initialize op.
[thirdparty/gcc.git] / gcc / df-scan.c
CommitLineData
e011eba9 1/* Scanning of rtl for dataflow analysis.
a2bdd643 2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
0ac758f7 3 2008, 2009 Free Software Foundation, Inc.
e011eba9 4 Originally contributed by Michael P. Hayes
5 (m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
6 Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
7 and Kenneth Zadeck (zadeck@naturalbridge.com).
8
9This file is part of GCC.
10
11GCC is free software; you can redistribute it and/or modify it under
12the terms of the GNU General Public License as published by the Free
8c4c00c1 13Software Foundation; either version 3, or (at your option) any later
e011eba9 14version.
15
16GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17WARRANTY; without even the implied warranty of MERCHANTABILITY or
18FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19for more details.
20
21You should have received a copy of the GNU General Public License
8c4c00c1 22along with GCC; see the file COPYING3. If not see
23<http://www.gnu.org/licenses/>. */
e011eba9 24
25#include "config.h"
26#include "system.h"
27#include "coretypes.h"
28#include "tm.h"
29#include "rtl.h"
30#include "tm_p.h"
31#include "insn-config.h"
32#include "recog.h"
33#include "function.h"
34#include "regs.h"
35#include "output.h"
36#include "alloc-pool.h"
37#include "flags.h"
38#include "hard-reg-set.h"
39#include "basic-block.h"
40#include "sbitmap.h"
41#include "bitmap.h"
42#include "timevar.h"
fcf2ad9f 43#include "tree.h"
44#include "target.h"
45#include "target-def.h"
e011eba9 46#include "df.h"
3072d30e 47#include "tree-pass.h"
e011eba9 48
f7f05a07 49DEF_VEC_P(df_ref);
50DEF_VEC_ALLOC_P_STACK(df_ref);
51
52#define VEC_df_ref_stack_alloc(alloc) VEC_stack_alloc (df_ref, alloc)
53
54typedef struct df_mw_hardreg *df_mw_hardreg_ptr;
55
56DEF_VEC_P(df_mw_hardreg_ptr);
57DEF_VEC_ALLOC_P_STACK(df_mw_hardreg_ptr);
58
59#define VEC_df_mw_hardreg_ptr_stack_alloc(alloc) \
60 VEC_stack_alloc (df_mw_hardreg_ptr, alloc)
61
e011eba9 62#ifndef HAVE_epilogue
63#define HAVE_epilogue 0
64#endif
65#ifndef HAVE_prologue
66#define HAVE_prologue 0
67#endif
68#ifndef HAVE_sibcall_epilogue
69#define HAVE_sibcall_epilogue 0
70#endif
71
72#ifndef EPILOGUE_USES
73#define EPILOGUE_USES(REGNO) 0
74#endif
75
ce299759 76/* The following two macros free the vecs that hold either the refs or
77 the mw refs. They are a little tricky because the vec has 0
78 elements is special and is not to be freed. */
79#define df_scan_free_ref_vec(V) \
80 do { \
81 if (V && *V) \
82 free (V); \
83 } while (0)
84
85#define df_scan_free_mws_vec(V) \
86 do { \
87 if (V && *V) \
88 free (V); \
89 } while (0)
90
e011eba9 91/* The set of hard registers in eliminables[i].from. */
92
93static HARD_REG_SET elim_reg_set;
94
e011eba9 95/* Initialize ur_in and ur_out as if all hard registers were partially
96 available. */
97
3072d30e 98struct df_collection_rec
99{
f7f05a07 100 VEC(df_ref,stack) *def_vec;
101 VEC(df_ref,stack) *use_vec;
102 VEC(df_ref,stack) *eq_use_vec;
103 VEC(df_mw_hardreg_ptr,stack) *mw_vec;
3072d30e 104};
105
ed6e85ae 106static df_ref df_null_ref_rec[1];
3072d30e 107static struct df_mw_hardreg * df_null_mw_rec[1];
108
ed6e85ae 109static void df_ref_record (enum df_ref_class, struct df_collection_rec *,
3072d30e 110 rtx, rtx *,
158b6cc9 111 basic_block, struct df_insn_info *,
b9c74b4d 112 enum df_ref_type, int ref_flags,
158b6cc9 113 int, int, enum machine_mode);
114static void df_def_record_1 (struct df_collection_rec *, rtx,
115 basic_block, struct df_insn_info *,
b9c74b4d 116 int ref_flags);
158b6cc9 117static void df_defs_record (struct df_collection_rec *, rtx,
118 basic_block, struct df_insn_info *,
b9c74b4d 119 int ref_flags);
ed6e85ae 120static void df_uses_record (enum df_ref_class, struct df_collection_rec *,
3072d30e 121 rtx *, enum df_ref_type,
158b6cc9 122 basic_block, struct df_insn_info *,
b9c74b4d 123 int ref_flags,
bf1f8fbc 124 int, int, enum machine_mode);
e011eba9 125
ed6e85ae 126static df_ref df_ref_create_structure (enum df_ref_class,
127 struct df_collection_rec *, rtx, rtx *,
128 basic_block, struct df_insn_info *,
b9c74b4d 129 enum df_ref_type, int ref_flags,
ed6e85ae 130 int, int, enum machine_mode);
3072d30e 131
132static void df_insn_refs_collect (struct df_collection_rec*,
158b6cc9 133 basic_block, struct df_insn_info *);
3072d30e 134static void df_canonize_collection_rec (struct df_collection_rec *);
135
136static void df_get_regular_block_artificial_uses (bitmap);
137static void df_get_eh_block_artificial_uses (bitmap);
138
139static void df_record_entry_block_defs (bitmap);
140static void df_record_exit_block_uses (bitmap);
141static void df_get_exit_block_use_set (bitmap);
142static void df_get_entry_block_def_set (bitmap);
e011eba9 143static void df_grow_ref_info (struct df_ref_info *, unsigned int);
ed6e85ae 144static void df_ref_chain_delete_du_chain (df_ref *);
145static void df_ref_chain_delete (df_ref *);
e011eba9 146
3072d30e 147static void df_refs_add_to_chains (struct df_collection_rec *,
148 basic_block, rtx);
149
150static bool df_insn_refs_verify (struct df_collection_rec *, basic_block, rtx, bool);
151static void df_entry_block_defs_collect (struct df_collection_rec *, bitmap);
152static void df_exit_block_uses_collect (struct df_collection_rec *, bitmap);
ed6e85ae 153static void df_install_ref (df_ref, struct df_reg_info *,
3072d30e 154 struct df_ref_info *, bool);
155
156static int df_ref_compare (const void *, const void *);
157static int df_mw_compare (const void *, const void *);
158
159/* Indexed by hardware reg number, is true if that register is ever
160 used in the current function.
161
162 In df-scan.c, this is set up to record the hard regs used
163 explicitly. Reload adds in the hard regs used for holding pseudo
164 regs. Final uses it to generate the code in the function prologue
165 and epilogue to save and restore registers as needed. */
166
167static bool regs_ever_live[FIRST_PSEUDO_REGISTER];
e011eba9 168\f
169/*----------------------------------------------------------------------------
170 SCANNING DATAFLOW PROBLEM
171
172 There are several ways in which scanning looks just like the other
173 dataflow problems. It shares the all the mechanisms for local info
174 as well as basic block info. Where it differs is when and how often
175 it gets run. It also has no need for the iterative solver.
176----------------------------------------------------------------------------*/
177
178/* Problem data for the scanning dataflow function. */
179struct df_scan_problem_data
180{
ed6e85ae 181 alloc_pool ref_base_pool;
182 alloc_pool ref_artificial_pool;
183 alloc_pool ref_regular_pool;
30de5b55 184 alloc_pool ref_extract_pool;
e011eba9 185 alloc_pool insn_pool;
186 alloc_pool reg_pool;
3e6933a8 187 alloc_pool mw_reg_pool;
3072d30e 188 bitmap_obstack reg_bitmaps;
189 bitmap_obstack insn_bitmaps;
e011eba9 190};
191
192typedef struct df_scan_bb_info *df_scan_bb_info_t;
193
ce299759 194
195/* Internal function to shut down the scanning problem. */
e011eba9 196static void
3072d30e 197df_scan_free_internal (void)
e011eba9 198{
3e6933a8 199 struct df_scan_problem_data *problem_data
3072d30e 200 = (struct df_scan_problem_data *) df_scan->problem_data;
ce299759 201 unsigned int i;
202 basic_block bb;
203
204 /* The vectors that hold the refs are not pool allocated because
205 they come in many sizes. This makes them impossible to delete
206 all at once. */
207 for (i = 0; i < DF_INSN_SIZE(); i++)
208 {
209 struct df_insn_info *insn_info = DF_INSN_UID_GET(i);
210 /* Skip the insns that have no insn_info or have been
211 deleted. */
212 if (insn_info)
213 {
214 df_scan_free_ref_vec (insn_info->defs);
215 df_scan_free_ref_vec (insn_info->uses);
216 df_scan_free_ref_vec (insn_info->eq_uses);
217 df_scan_free_mws_vec (insn_info->mw_hardregs);
218 }
219 }
220
221 FOR_ALL_BB (bb)
222 {
223 unsigned int bb_index = bb->index;
224 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb_index);
225 if (bb_info)
226 {
227 df_scan_free_ref_vec (bb_info->artificial_defs);
228 df_scan_free_ref_vec (bb_info->artificial_uses);
229 }
230 }
e011eba9 231
e011eba9 232 free (df->def_info.refs);
3072d30e 233 free (df->def_info.begin);
234 free (df->def_info.count);
e011eba9 235 memset (&df->def_info, 0, (sizeof (struct df_ref_info)));
236
e011eba9 237 free (df->use_info.refs);
3072d30e 238 free (df->use_info.begin);
239 free (df->use_info.count);
e011eba9 240 memset (&df->use_info, 0, (sizeof (struct df_ref_info)));
241
3072d30e 242 free (df->def_regs);
243 df->def_regs = NULL;
244 free (df->use_regs);
245 df->use_regs = NULL;
246 free (df->eq_use_regs);
247 df->eq_use_regs = NULL;
248 df->regs_size = 0;
249 DF_REG_SIZE(df) = 0;
250
e011eba9 251 free (df->insns);
252 df->insns = NULL;
3072d30e 253 DF_INSN_SIZE () = 0;
e011eba9 254
3072d30e 255 free (df_scan->block_info);
256 df_scan->block_info = NULL;
257 df_scan->block_info_size = 0;
e011eba9 258
259 BITMAP_FREE (df->hardware_regs_used);
3072d30e 260 BITMAP_FREE (df->regular_block_artificial_uses);
261 BITMAP_FREE (df->eh_block_artificial_uses);
fcf2ad9f 262 BITMAP_FREE (df->entry_block_defs);
e011eba9 263 BITMAP_FREE (df->exit_block_uses);
3072d30e 264 BITMAP_FREE (df->insns_to_delete);
265 BITMAP_FREE (df->insns_to_rescan);
266 BITMAP_FREE (df->insns_to_notes_rescan);
e011eba9 267
3072d30e 268 free_alloc_pool (df_scan->block_pool);
ed6e85ae 269 free_alloc_pool (problem_data->ref_base_pool);
270 free_alloc_pool (problem_data->ref_artificial_pool);
271 free_alloc_pool (problem_data->ref_regular_pool);
30de5b55 272 free_alloc_pool (problem_data->ref_extract_pool);
e011eba9 273 free_alloc_pool (problem_data->insn_pool);
274 free_alloc_pool (problem_data->reg_pool);
3e6933a8 275 free_alloc_pool (problem_data->mw_reg_pool);
3072d30e 276 bitmap_obstack_release (&problem_data->reg_bitmaps);
277 bitmap_obstack_release (&problem_data->insn_bitmaps);
278 free (df_scan->problem_data);
e011eba9 279}
280
281
282/* Set basic block info. */
283
284static void
3072d30e 285df_scan_set_bb_info (unsigned int index,
e011eba9 286 struct df_scan_bb_info *bb_info)
287{
3072d30e 288 gcc_assert (df_scan);
289 df_grow_bb_info (df_scan);
290 df_scan->block_info[index] = (void *) bb_info;
e011eba9 291}
292
293
294/* Free basic block info. */
295
296static void
3072d30e 297df_scan_free_bb_info (basic_block bb, void *vbb_info)
e011eba9 298{
299 struct df_scan_bb_info *bb_info = (struct df_scan_bb_info *) vbb_info;
3072d30e 300 unsigned int bb_index = bb->index;
e011eba9 301 if (bb_info)
d0802b39 302 {
3072d30e 303 rtx insn;
304 FOR_BB_INSNS (bb, insn)
305 {
306 if (INSN_P (insn))
307 /* Record defs within INSN. */
308 df_insn_delete (bb, INSN_UID (insn));
309 }
310
311 if (bb_index < df_scan->block_info_size)
312 bb_info = df_scan_get_bb_info (bb_index);
313
314 /* Get rid of any artificial uses or defs. */
315 df_ref_chain_delete_du_chain (bb_info->artificial_defs);
316 df_ref_chain_delete_du_chain (bb_info->artificial_uses);
317 df_ref_chain_delete (bb_info->artificial_defs);
318 df_ref_chain_delete (bb_info->artificial_uses);
319 bb_info->artificial_defs = NULL;
320 bb_info->artificial_uses = NULL;
321 pool_free (df_scan->block_pool, bb_info);
d0802b39 322 }
e011eba9 323}
324
325
326/* Allocate the problem data for the scanning problem. This should be
327 called when the problem is created or when the entire function is to
328 be rescanned. */
3072d30e 329void
330df_scan_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
e011eba9 331{
e011eba9 332 struct df_scan_problem_data *problem_data;
333 unsigned int insn_num = get_max_uid () + 1;
3072d30e 334 unsigned int block_size = 400;
335 basic_block bb;
e011eba9 336
337 /* Given the number of pools, this is really faster than tearing
338 everything apart. */
3072d30e 339 if (df_scan->problem_data)
340 df_scan_free_internal ();
e011eba9 341
3072d30e 342 df_scan->block_pool
e011eba9 343 = create_alloc_pool ("df_scan_block pool",
344 sizeof (struct df_scan_bb_info),
345 block_size);
346
4c36ffe6 347 problem_data = XNEW (struct df_scan_problem_data);
3072d30e 348 df_scan->problem_data = problem_data;
349 df_scan->computed = true;
e011eba9 350
ed6e85ae 351 problem_data->ref_base_pool
352 = create_alloc_pool ("df_scan ref base",
353 sizeof (struct df_base_ref), block_size);
354 problem_data->ref_artificial_pool
355 = create_alloc_pool ("df_scan ref artificial",
356 sizeof (struct df_artificial_ref), block_size);
357 problem_data->ref_regular_pool
358 = create_alloc_pool ("df_scan ref regular",
359 sizeof (struct df_regular_ref), block_size);
30de5b55 360 problem_data->ref_extract_pool
ed6e85ae 361 = create_alloc_pool ("df_scan ref extract",
362 sizeof (struct df_extract_ref), block_size);
e011eba9 363 problem_data->insn_pool
ed6e85ae 364 = create_alloc_pool ("df_scan insn",
e011eba9 365 sizeof (struct df_insn_info), block_size);
e011eba9 366 problem_data->reg_pool
ed6e85ae 367 = create_alloc_pool ("df_scan reg",
e011eba9 368 sizeof (struct df_reg_info), block_size);
3e6933a8 369 problem_data->mw_reg_pool
ed6e85ae 370 = create_alloc_pool ("df_scan mw_reg",
3e6933a8 371 sizeof (struct df_mw_hardreg), block_size);
e011eba9 372
3072d30e 373 bitmap_obstack_initialize (&problem_data->reg_bitmaps);
374 bitmap_obstack_initialize (&problem_data->insn_bitmaps);
e011eba9 375
3072d30e 376 insn_num += insn_num / 4;
377 df_grow_reg_info ();
e011eba9 378
3072d30e 379 df_grow_insn_info ();
380 df_grow_bb_info (df_scan);
e011eba9 381
3072d30e 382 FOR_ALL_BB (bb)
e011eba9 383 {
3072d30e 384 unsigned int bb_index = bb->index;
385 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb_index);
e011eba9 386 if (!bb_info)
387 {
3072d30e 388 bb_info = (struct df_scan_bb_info *) pool_alloc (df_scan->block_pool);
389 df_scan_set_bb_info (bb_index, bb_info);
e011eba9 390 }
391 bb_info->artificial_defs = NULL;
392 bb_info->artificial_uses = NULL;
393 }
394
3072d30e 395 df->hardware_regs_used = BITMAP_ALLOC (&problem_data->reg_bitmaps);
396 df->regular_block_artificial_uses = BITMAP_ALLOC (&problem_data->reg_bitmaps);
397 df->eh_block_artificial_uses = BITMAP_ALLOC (&problem_data->reg_bitmaps);
398 df->entry_block_defs = BITMAP_ALLOC (&problem_data->reg_bitmaps);
399 df->exit_block_uses = BITMAP_ALLOC (&problem_data->reg_bitmaps);
400 df->insns_to_delete = BITMAP_ALLOC (&problem_data->insn_bitmaps);
401 df->insns_to_rescan = BITMAP_ALLOC (&problem_data->insn_bitmaps);
402 df->insns_to_notes_rescan = BITMAP_ALLOC (&problem_data->insn_bitmaps);
deb2741b 403 df_scan->optional_p = false;
e011eba9 404}
405
406
407/* Free all of the data associated with the scan problem. */
408
409static void
3072d30e 410df_scan_free (void)
e011eba9 411{
3072d30e 412 if (df_scan->problem_data)
413 df_scan_free_internal ();
d0802b39 414
e011eba9 415 if (df->blocks_to_analyze)
3072d30e 416 {
417 BITMAP_FREE (df->blocks_to_analyze);
418 df->blocks_to_analyze = NULL;
419 }
e011eba9 420
3072d30e 421 free (df_scan);
e011eba9 422}
423
3072d30e 424/* Dump the preamble for DF_SCAN dump. */
e011eba9 425static void
3072d30e 426df_scan_start_dump (FILE *file ATTRIBUTE_UNUSED)
e011eba9 427{
e011eba9 428 int i;
ed6e85ae 429 int dcount = 0;
430 int ucount = 0;
431 int ecount = 0;
432 int icount = 0;
433 int ccount = 0;
434 basic_block bb;
435 rtx insn;
e011eba9 436
3072d30e 437 fprintf (file, ";; invalidated by call \t");
b888113c 438 df_print_regset (file, regs_invalidated_by_call_regset);
3072d30e 439 fprintf (file, ";; hardware regs used \t");
440 df_print_regset (file, df->hardware_regs_used);
441 fprintf (file, ";; regular block artificial uses \t");
442 df_print_regset (file, df->regular_block_artificial_uses);
443 fprintf (file, ";; eh block artificial uses \t");
444 df_print_regset (file, df->eh_block_artificial_uses);
445 fprintf (file, ";; entry block defs \t");
446 df_print_regset (file, df->entry_block_defs);
447 fprintf (file, ";; exit block uses \t");
448 df_print_regset (file, df->exit_block_uses);
449 fprintf (file, ";; regs ever live \t");
e011eba9 450 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3072d30e 451 if (df_regs_ever_live_p (i))
452 fprintf (file, " %d[%s]", i, reg_names[i]);
ed6e85ae 453 fprintf (file, "\n;; ref usage \t");
454
455 for (i = 0; i < (int)df->regs_inited; i++)
456 if (DF_REG_DEF_COUNT (i) || DF_REG_USE_COUNT (i) || DF_REG_EQ_USE_COUNT (i))
457 {
458 const char * sep = "";
459
460 fprintf (file, "r%d={", i);
461 if (DF_REG_DEF_COUNT (i))
462 {
463 fprintf (file, "%dd", DF_REG_DEF_COUNT (i));
464 sep = ",";
465 dcount += DF_REG_DEF_COUNT (i);
466 }
467 if (DF_REG_USE_COUNT (i))
468 {
469 fprintf (file, "%s%du", sep, DF_REG_USE_COUNT (i));
470 sep = ",";
471 ucount += DF_REG_USE_COUNT (i);
472 }
473 if (DF_REG_EQ_USE_COUNT (i))
474 {
475 fprintf (file, "%s%dd", sep, DF_REG_EQ_USE_COUNT (i));
476 ecount += DF_REG_EQ_USE_COUNT (i);
477 }
478 fprintf (file, "} ");
479 }
3072d30e 480
ed6e85ae 481 FOR_EACH_BB (bb)
482 FOR_BB_INSNS (bb, insn)
483 if (INSN_P (insn))
484 {
485 if (CALL_P (insn))
486 ccount++;
487 else
488 icount++;
489 }
490
491 fprintf (file, "\n;; total ref usage %d{%dd,%du,%de} in %d{%d regular + %d call} insns.\n",
492 dcount + ucount + ecount, dcount, ucount, ecount, icount + ccount, icount, ccount);
e011eba9 493}
494
3072d30e 495/* Dump the bb_info for a given basic block. */
496static void
497df_scan_start_block (basic_block bb, FILE *file)
498{
499 struct df_scan_bb_info *bb_info
500 = df_scan_get_bb_info (bb->index);
501
502 if (bb_info)
503 {
504 fprintf (file, ";; bb %d artificial_defs: ", bb->index);
505 df_refs_chain_dump (bb_info->artificial_defs, true, file);
506 fprintf (file, "\n;; bb %d artificial_uses: ", bb->index);
507 df_refs_chain_dump (bb_info->artificial_uses, true, file);
508 fprintf (file, "\n");
509 }
510#if 0
511 {
512 rtx insn;
513 FOR_BB_INSNS (bb, insn)
514 if (INSN_P (insn))
515 df_insn_debug (insn, false, file);
516 }
517#endif
518}
519
e011eba9 520static struct df_problem problem_SCAN =
521{
522 DF_SCAN, /* Problem id. */
523 DF_NONE, /* Direction. */
524 df_scan_alloc, /* Allocate the problem specific data. */
f64e6a69 525 NULL, /* Reset global information. */
e011eba9 526 df_scan_free_bb_info, /* Free basic block info. */
527 NULL, /* Local compute function. */
528 NULL, /* Init the solution specific data. */
529 NULL, /* Iterative solver. */
530 NULL, /* Confluence operator 0. */
531 NULL, /* Confluence operator n. */
532 NULL, /* Transfer function. */
533 NULL, /* Finalize function. */
534 df_scan_free, /* Free all of the problem information. */
3072d30e 535 NULL, /* Remove this problem from the stack of dataflow problems. */
536 df_scan_start_dump, /* Debugging. */
537 df_scan_start_block, /* Debugging start block. */
538 NULL, /* Debugging end block. */
539 NULL, /* Incremental solution verify start. */
6dfdc153 540 NULL, /* Incremental solution verify end. */
3e6933a8 541 NULL, /* Dependent problem. */
deb2741b 542 TV_DF_SCAN, /* Timing variable. */
543 false /* Reset blocks on dropping out of blocks_to_analyze. */
e011eba9 544};
545
546
547/* Create a new DATAFLOW instance and add it to an existing instance
548 of DF. The returned structure is what is used to get at the
549 solution. */
550
3072d30e 551void
552df_scan_add_problem (void)
e011eba9 553{
3072d30e 554 df_add_problem (&problem_SCAN);
e011eba9 555}
556
3072d30e 557\f
e011eba9 558/*----------------------------------------------------------------------------
559 Storage Allocation Utilities
560----------------------------------------------------------------------------*/
561
562
563/* First, grow the reg_info information. If the current size is less than
f0b5f617 564 the number of pseudos, grow to 25% more than the number of
e011eba9 565 pseudos.
566
567 Second, assure that all of the slots up to max_reg_num have been
568 filled with reg_info structures. */
569
3072d30e 570void
571df_grow_reg_info (void)
e011eba9 572{
573 unsigned int max_reg = max_reg_num ();
574 unsigned int new_size = max_reg;
3e6933a8 575 struct df_scan_problem_data *problem_data
3072d30e 576 = (struct df_scan_problem_data *) df_scan->problem_data;
e011eba9 577 unsigned int i;
578
3072d30e 579 if (df->regs_size < new_size)
e011eba9 580 {
581 new_size += new_size / 4;
364c0c59 582 df->def_regs = XRESIZEVEC (struct df_reg_info *, df->def_regs, new_size);
583 df->use_regs = XRESIZEVEC (struct df_reg_info *, df->use_regs, new_size);
584 df->eq_use_regs = XRESIZEVEC (struct df_reg_info *, df->eq_use_regs,
585 new_size);
586 df->def_info.begin = XRESIZEVEC (unsigned, df->def_info.begin, new_size);
587 df->def_info.count = XRESIZEVEC (unsigned, df->def_info.count, new_size);
588 df->use_info.begin = XRESIZEVEC (unsigned, df->use_info.begin, new_size);
589 df->use_info.count = XRESIZEVEC (unsigned, df->use_info.count, new_size);
3072d30e 590 df->regs_size = new_size;
e011eba9 591 }
592
3072d30e 593 for (i = df->regs_inited; i < max_reg; i++)
e011eba9 594 {
3072d30e 595 struct df_reg_info *reg_info;
596
364c0c59 597 reg_info = (struct df_reg_info *) pool_alloc (problem_data->reg_pool);
3072d30e 598 memset (reg_info, 0, sizeof (struct df_reg_info));
599 df->def_regs[i] = reg_info;
364c0c59 600 reg_info = (struct df_reg_info *) pool_alloc (problem_data->reg_pool);
3072d30e 601 memset (reg_info, 0, sizeof (struct df_reg_info));
602 df->use_regs[i] = reg_info;
364c0c59 603 reg_info = (struct df_reg_info *) pool_alloc (problem_data->reg_pool);
e011eba9 604 memset (reg_info, 0, sizeof (struct df_reg_info));
3072d30e 605 df->eq_use_regs[i] = reg_info;
606 df->def_info.begin[i] = 0;
607 df->def_info.count[i] = 0;
608 df->use_info.begin[i] = 0;
609 df->use_info.count[i] = 0;
e011eba9 610 }
611
3072d30e 612 df->regs_inited = max_reg;
e011eba9 613}
614
615
616/* Grow the ref information. */
617
618static void
619df_grow_ref_info (struct df_ref_info *ref_info, unsigned int new_size)
620{
621 if (ref_info->refs_size < new_size)
622 {
ed6e85ae 623 ref_info->refs = XRESIZEVEC (df_ref, ref_info->refs, new_size);
e011eba9 624 memset (ref_info->refs + ref_info->refs_size, 0,
ed6e85ae 625 (new_size - ref_info->refs_size) *sizeof (df_ref));
e011eba9 626 ref_info->refs_size = new_size;
627 }
628}
629
630
3072d30e 631/* Check and grow the ref information if necessary. This routine
632 guarantees total_size + BITMAP_ADDEND amount of entries in refs
633 array. It updates ref_info->refs_size only and does not change
634 ref_info->total_size. */
635
636static void
637df_check_and_grow_ref_info (struct df_ref_info *ref_info,
638 unsigned bitmap_addend)
639{
640 if (ref_info->refs_size < ref_info->total_size + bitmap_addend)
641 {
642 int new_size = ref_info->total_size + bitmap_addend;
643 new_size += ref_info->total_size / 4;
644 df_grow_ref_info (ref_info, new_size);
645 }
646}
647
648
e011eba9 649/* Grow the ref information. If the current size is less than the
650 number of instructions, grow to 25% more than the number of
651 instructions. */
652
3072d30e 653void
654df_grow_insn_info (void)
e011eba9 655{
656 unsigned int new_size = get_max_uid () + 1;
3072d30e 657 if (DF_INSN_SIZE () < new_size)
e011eba9 658 {
659 new_size += new_size / 4;
364c0c59 660 df->insns = XRESIZEVEC (struct df_insn_info *, df->insns, new_size);
e011eba9 661 memset (df->insns + df->insns_size, 0,
3072d30e 662 (new_size - DF_INSN_SIZE ()) *sizeof (struct df_insn_info *));
663 DF_INSN_SIZE () = new_size;
e011eba9 664 }
665}
666
667
668
669\f
670/*----------------------------------------------------------------------------
671 PUBLIC INTERFACES FOR SMALL GRAIN CHANGES TO SCANNING.
672----------------------------------------------------------------------------*/
673
3072d30e 674/* Rescan all of the block_to_analyze or all of the blocks in the
675 function if df_set_blocks if blocks_to_analyze is NULL; */
e011eba9 676
677void
3072d30e 678df_scan_blocks (void)
e011eba9 679{
e011eba9 680 basic_block bb;
681
3072d30e 682 df->def_info.ref_order = DF_REF_ORDER_NO_TABLE;
683 df->use_info.ref_order = DF_REF_ORDER_NO_TABLE;
3e6933a8 684
3072d30e 685 df_get_regular_block_artificial_uses (df->regular_block_artificial_uses);
686 df_get_eh_block_artificial_uses (df->eh_block_artificial_uses);
e011eba9 687
3072d30e 688 bitmap_ior_into (df->eh_block_artificial_uses,
689 df->regular_block_artificial_uses);
f64e6a69 690
3072d30e 691 /* ENTRY and EXIT blocks have special defs/uses. */
692 df_get_entry_block_def_set (df->entry_block_defs);
693 df_record_entry_block_defs (df->entry_block_defs);
694 df_get_exit_block_use_set (df->exit_block_uses);
695 df_record_exit_block_uses (df->exit_block_uses);
696 df_set_bb_dirty (BASIC_BLOCK (ENTRY_BLOCK));
697 df_set_bb_dirty (BASIC_BLOCK (EXIT_BLOCK));
e011eba9 698
3072d30e 699 /* Regular blocks */
700 FOR_EACH_BB (bb)
e011eba9 701 {
3072d30e 702 unsigned int bb_index = bb->index;
703 df_bb_refs_record (bb_index, true);
e011eba9 704 }
e011eba9 705}
706
3e6933a8 707
e011eba9 708/* Create a new ref of type DF_REF_TYPE for register REG at address
30de5b55 709 LOC within INSN of BB. This function is only used externally.
710
711 If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
bf1f8fbc 712 DF_REF_ZERO_EXTRACT. WIDTH, OFFSET and MODE are used to access the
713 fields if they were constants. Otherwise they should be -1 if
714 those flags were set. */
e011eba9 715
ed6e85ae 716df_ref
3072d30e 717df_ref_create (rtx reg, rtx *loc, rtx insn,
e011eba9 718 basic_block bb,
719 enum df_ref_type ref_type,
b9c74b4d 720 int ref_flags,
bf1f8fbc 721 int width, int offset, enum machine_mode mode)
e011eba9 722{
ed6e85ae 723 df_ref ref;
3072d30e 724 struct df_reg_info **reg_info;
725 struct df_ref_info *ref_info;
ed6e85ae 726 df_ref *ref_rec;
727 df_ref **ref_rec_ptr;
3072d30e 728 unsigned int count = 0;
729 bool add_to_table;
ed6e85ae 730 enum df_ref_class cl;
e011eba9 731
3072d30e 732 df_grow_reg_info ();
e011eba9 733
3072d30e 734 /* You cannot hack artificial refs. */
735 gcc_assert (insn);
ed6e85ae 736
737 if (width != -1 || offset != -1)
738 cl = DF_REF_EXTRACT;
739 else if (loc)
740 cl = DF_REF_REGULAR;
741 else
742 cl = DF_REF_BASE;
743 ref = df_ref_create_structure (cl, NULL, reg, loc, bb, DF_INSN_INFO_GET (insn),
bf1f8fbc 744 ref_type, ref_flags,
745 width, offset, mode);
e011eba9 746
ed6e85ae 747 if (DF_REF_REG_DEF_P (ref))
3072d30e 748 {
749 reg_info = df->def_regs;
750 ref_info = &df->def_info;
751 ref_rec_ptr = &DF_INSN_DEFS (insn);
752 add_to_table = ref_info->ref_order != DF_REF_ORDER_NO_TABLE;
753 }
754 else if (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE)
755 {
756 reg_info = df->eq_use_regs;
757 ref_info = &df->use_info;
758 ref_rec_ptr = &DF_INSN_EQ_USES (insn);
759 switch (ref_info->ref_order)
760 {
761 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
762 case DF_REF_ORDER_BY_REG_WITH_NOTES:
763 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
764 add_to_table = true;
765 break;
766 default:
767 add_to_table = false;
768 break;
769 }
770 }
771 else
772 {
773 reg_info = df->use_regs;
774 ref_info = &df->use_info;
775 ref_rec_ptr = &DF_INSN_USES (insn);
776 add_to_table = ref_info->ref_order != DF_REF_ORDER_NO_TABLE;
777 }
e011eba9 778
3072d30e 779 /* Do not add if ref is not in the right blocks. */
780 if (add_to_table && df->analyze_subset)
781 add_to_table = bitmap_bit_p (df->blocks_to_analyze, bb->index);
e011eba9 782
3072d30e 783 df_install_ref (ref, reg_info[DF_REF_REGNO (ref)], ref_info, add_to_table);
784
785 if (add_to_table)
786 switch (ref_info->ref_order)
787 {
788 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
789 case DF_REF_ORDER_BY_REG_WITH_NOTES:
790 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
791 ref_info->ref_order = DF_REF_ORDER_UNORDERED_WITH_NOTES;
792 break;
793 default:
794 ref_info->ref_order = DF_REF_ORDER_UNORDERED;
795 break;
796 }
e011eba9 797
3072d30e 798 ref_rec = *ref_rec_ptr;
799 while (*ref_rec)
800 {
801 count++;
802 ref_rec++;
803 }
e011eba9 804
3072d30e 805 ref_rec = *ref_rec_ptr;
806 if (count)
e011eba9 807 {
ed6e85ae 808 ref_rec = XRESIZEVEC (df_ref, ref_rec, count+2);
3072d30e 809 *ref_rec_ptr = ref_rec;
810 ref_rec[count] = ref;
811 ref_rec[count+1] = NULL;
ed6e85ae 812 qsort (ref_rec, count + 1, sizeof (df_ref), df_ref_compare);
3072d30e 813 }
814 else
815 {
ed6e85ae 816 df_ref *ref_rec = XNEWVEC (df_ref, 2);
3072d30e 817 ref_rec[0] = ref;
818 ref_rec[1] = NULL;
819 *ref_rec_ptr = ref_rec;
820 }
e011eba9 821
3072d30e 822#if 0
823 if (dump_file)
824 {
825 fprintf (dump_file, "adding ref ");
826 df_ref_debug (ref, dump_file);
e011eba9 827 }
3072d30e 828#endif
829 /* By adding the ref directly, df_insn_rescan my not find any
830 differences even though the block will have changed. So we need
831 to mark the block dirty ourselves. */
832 df_set_bb_dirty (bb);
e011eba9 833
3072d30e 834 return ref;
e011eba9 835}
836
837
3072d30e 838\f
839/*----------------------------------------------------------------------------
840 UTILITIES TO CREATE AND DESTROY REFS AND CHAINS.
841----------------------------------------------------------------------------*/
842
30de5b55 843static void
ed6e85ae 844df_free_ref (df_ref ref)
30de5b55 845{
846 struct df_scan_problem_data *problem_data
847 = (struct df_scan_problem_data *) df_scan->problem_data;
848
ed6e85ae 849 switch (DF_REF_CLASS (ref))
850 {
851 case DF_REF_BASE:
852 pool_free (problem_data->ref_base_pool, ref);
853 break;
854
855 case DF_REF_ARTIFICIAL:
856 pool_free (problem_data->ref_artificial_pool, ref);
857 break;
858
859 case DF_REF_REGULAR:
860 pool_free (problem_data->ref_regular_pool, ref);
861 break;
862
863 case DF_REF_EXTRACT:
864 pool_free (problem_data->ref_extract_pool, ref);
865 break;
866 }
30de5b55 867}
868
e011eba9 869
3072d30e 870/* Unlink and delete REF at the reg_use, reg_eq_use or reg_def chain.
871 Also delete the def-use or use-def chain if it exists. */
872
873static void
ed6e85ae 874df_reg_chain_unlink (df_ref ref)
e011eba9 875{
ed6e85ae 876 df_ref next = DF_REF_NEXT_REG (ref);
877 df_ref prev = DF_REF_PREV_REG (ref);
3072d30e 878 int id = DF_REF_ID (ref);
e011eba9 879 struct df_reg_info *reg_info;
ed6e85ae 880 df_ref *refs = NULL;
e011eba9 881
ed6e85ae 882 if (DF_REF_REG_DEF_P (ref))
e011eba9 883 {
ed6e85ae 884 int regno = DF_REF_REGNO (ref);
885 reg_info = DF_REG_DEF_GET (regno);
3072d30e 886 refs = df->def_info.refs;
e011eba9 887 }
888 else
889 {
3072d30e 890 if (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE)
891 {
892 reg_info = DF_REG_EQ_USE_GET (DF_REF_REGNO (ref));
893 switch (df->use_info.ref_order)
894 {
895 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
896 case DF_REF_ORDER_BY_REG_WITH_NOTES:
897 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
898 refs = df->use_info.refs;
899 break;
900 default:
901 break;
902 }
903 }
904 else
905 {
906 reg_info = DF_REG_USE_GET (DF_REF_REGNO (ref));
907 refs = df->use_info.refs;
908 }
909 }
910
911 if (refs)
912 {
913 if (df->analyze_subset)
914 {
ed6e85ae 915 if (bitmap_bit_p (df->blocks_to_analyze, DF_REF_BBNO (ref)))
3072d30e 916 refs[id] = NULL;
917 }
918 else
919 refs[id] = NULL;
e011eba9 920 }
921
3072d30e 922 /* Delete any def-use or use-def chains that start here. It is
923 possible that there is trash in this field. This happens for
924 insns that have been deleted when rescanning has been deferred
925 and the chain problem has also been deleted. The chain tear down
926 code skips deleted insns. */
927 if (df_chain && DF_REF_CHAIN (ref))
928 df_chain_unlink (ref);
929
e011eba9 930 reg_info->n_refs--;
3072d30e 931 if (DF_REF_FLAGS_IS_SET (ref, DF_HARD_REG_LIVE))
932 {
933 gcc_assert (DF_REF_REGNO (ref) < FIRST_PSEUDO_REGISTER);
934 df->hard_regs_live_count[DF_REF_REGNO (ref)]--;
935 }
e011eba9 936
937 /* Unlink from the reg chain. If there is no prev, this is the
938 first of the list. If not, just join the next and prev. */
939 if (prev)
3072d30e 940 DF_REF_NEXT_REG (prev) = next;
e011eba9 941 else
942 {
3072d30e 943 gcc_assert (reg_info->reg_chain == ref);
e011eba9 944 reg_info->reg_chain = next;
e011eba9 945 }
3072d30e 946 if (next)
947 DF_REF_PREV_REG (next) = prev;
e011eba9 948
30de5b55 949 df_free_ref (ref);
3072d30e 950}
951
952
953/* Remove REF from VEC. */
954
955static void
ed6e85ae 956df_ref_compress_rec (df_ref **vec_ptr, df_ref ref)
3072d30e 957{
ed6e85ae 958 df_ref *vec = *vec_ptr;
3072d30e 959
960 if (vec[1])
961 {
962 while (*vec && *vec != ref)
963 vec++;
964
965 while (*vec)
966 {
967 *vec = *(vec+1);
968 vec++;
969 }
970 }
971 else
972 {
973 free (vec);
974 *vec_ptr = df_null_ref_rec;
975 }
e011eba9 976}
977
978
979/* Unlink REF from all def-use/use-def chains, etc. */
980
981void
ed6e85ae 982df_ref_remove (df_ref ref)
e011eba9 983{
3072d30e 984#if 0
985 if (dump_file)
986 {
987 fprintf (dump_file, "removing ref ");
988 df_ref_debug (ref, dump_file);
989 }
990#endif
991
e011eba9 992 if (DF_REF_REG_DEF_P (ref))
993 {
3072d30e 994 if (DF_REF_IS_ARTIFICIAL (ref))
e011eba9 995 {
996 struct df_scan_bb_info *bb_info
ed6e85ae 997 = df_scan_get_bb_info (DF_REF_BBNO (ref));
3072d30e 998 df_ref_compress_rec (&bb_info->artificial_defs, ref);
e011eba9 999 }
1000 else
3072d30e 1001 {
1002 unsigned int uid = DF_REF_INSN_UID (ref);
1003 struct df_insn_info *insn_rec = DF_INSN_UID_GET (uid);
1004 df_ref_compress_rec (&insn_rec->defs, ref);
1005 }
e011eba9 1006 }
1007 else
1008 {
3072d30e 1009 if (DF_REF_IS_ARTIFICIAL (ref))
e011eba9 1010 {
1011 struct df_scan_bb_info *bb_info
ed6e85ae 1012 = df_scan_get_bb_info (DF_REF_BBNO (ref));
3072d30e 1013 df_ref_compress_rec (&bb_info->artificial_uses, ref);
1014 }
1015 else
1016 {
1017 unsigned int uid = DF_REF_INSN_UID (ref);
1018 struct df_insn_info *insn_rec = DF_INSN_UID_GET (uid);
1019
1020 if (DF_REF_FLAGS (ref) & DF_REF_IN_NOTE)
1021 df_ref_compress_rec (&insn_rec->eq_uses, ref);
1022 else
1023 df_ref_compress_rec (&insn_rec->uses, ref);
e011eba9 1024 }
e011eba9 1025 }
1026
3072d30e 1027 /* By deleting the ref directly, df_insn_rescan my not find any
1028 differences even though the block will have changed. So we need
1029 to mark the block dirty ourselves. */
1030 df_set_bb_dirty (DF_REF_BB (ref));
1031 df_reg_chain_unlink (ref);
e011eba9 1032}
1033
1034
3072d30e 1035/* Create the insn record for INSN. If there was one there, zero it
1036 out. */
e011eba9 1037
3072d30e 1038struct df_insn_info *
1039df_insn_create_insn_record (rtx insn)
e011eba9 1040{
3e6933a8 1041 struct df_scan_problem_data *problem_data
3072d30e 1042 = (struct df_scan_problem_data *) df_scan->problem_data;
1043 struct df_insn_info *insn_rec;
e011eba9 1044
3072d30e 1045 df_grow_insn_info ();
158b6cc9 1046 insn_rec = DF_INSN_INFO_GET (insn);
e011eba9 1047 if (!insn_rec)
1048 {
364c0c59 1049 insn_rec = (struct df_insn_info *) pool_alloc (problem_data->insn_pool);
158b6cc9 1050 DF_INSN_INFO_SET (insn, insn_rec);
e011eba9 1051 }
1052 memset (insn_rec, 0, sizeof (struct df_insn_info));
3072d30e 1053 insn_rec->insn = insn;
e011eba9 1054 return insn_rec;
1055}
1056
d0802b39 1057
3072d30e 1058/* Delete all du chain (DF_REF_CHAIN()) of all refs in the ref chain. */
e011eba9 1059
3072d30e 1060static void
ed6e85ae 1061df_ref_chain_delete_du_chain (df_ref *ref_rec)
e011eba9 1062{
3072d30e 1063 while (*ref_rec)
e011eba9 1064 {
ed6e85ae 1065 df_ref ref = *ref_rec;
3072d30e 1066 /* CHAIN is allocated by DF_CHAIN. So make sure to
1067 pass df_scan instance for the problem. */
1068 if (DF_REF_CHAIN (ref))
1069 df_chain_unlink (ref);
1070 ref_rec++;
1071 }
1072}
3e6933a8 1073
e011eba9 1074
3072d30e 1075/* Delete all refs in the ref chain. */
1076
1077static void
ed6e85ae 1078df_ref_chain_delete (df_ref *ref_rec)
3072d30e 1079{
ed6e85ae 1080 df_ref *start = ref_rec;
3072d30e 1081 while (*ref_rec)
1082 {
1083 df_reg_chain_unlink (*ref_rec);
1084 ref_rec++;
1085 }
1086
1087 /* If the list is empty, it has a special shared element that is not
1088 to be deleted. */
1089 if (*start)
1090 free (start);
1091}
1092
1093
1094/* Delete the hardreg chain. */
1095
1096static void
1097df_mw_hardreg_chain_delete (struct df_mw_hardreg **hardregs)
1098{
1099 struct df_scan_problem_data *problem_data;
1100
1101 if (!hardregs)
1102 return;
1103
1104 problem_data = (struct df_scan_problem_data *) df_scan->problem_data;
1105
1106 while (*hardregs)
1107 {
1108 pool_free (problem_data->mw_reg_pool, *hardregs);
1109 hardregs++;
1110 }
1111}
1112
1113
1114/* Delete all of the refs information from INSN. BB must be passed in
1115 except when called from df_process_deferred_rescans to mark the block
1116 as dirty. */
1117
1118void
1119df_insn_delete (basic_block bb, unsigned int uid)
1120{
1121 struct df_insn_info *insn_info = NULL;
1122 if (!df)
1123 return;
1124
1125 df_grow_bb_info (df_scan);
1126 df_grow_reg_info ();
1127
1128 /* The block must be marked as dirty now, rather than later as in
1129 df_insn_rescan and df_notes_rescan because it may not be there at
1130 rescanning time and the mark would blow up. */
1131 if (bb)
1132 df_set_bb_dirty (bb);
1133
1134 insn_info = DF_INSN_UID_SAFE_GET (uid);
1135
a3de79f9 1136 /* The client has deferred rescanning. */
3072d30e 1137 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
1138 {
1139 if (insn_info)
1140 {
1141 bitmap_clear_bit (df->insns_to_rescan, uid);
1142 bitmap_clear_bit (df->insns_to_notes_rescan, uid);
1143 bitmap_set_bit (df->insns_to_delete, uid);
1144 }
1145 if (dump_file)
bff9eb26 1146 fprintf (dump_file, "deferring deletion of insn with uid = %d.\n", uid);
3072d30e 1147 return;
1148 }
1149
1150 if (dump_file)
1151 fprintf (dump_file, "deleting insn with uid = %d.\n", uid);
1152
1153 bitmap_clear_bit (df->insns_to_delete, uid);
1154 bitmap_clear_bit (df->insns_to_rescan, uid);
1155 bitmap_clear_bit (df->insns_to_notes_rescan, uid);
1156 if (insn_info)
1157 {
1158 struct df_scan_problem_data *problem_data
1159 = (struct df_scan_problem_data *) df_scan->problem_data;
1160
1161 /* In general, notes do not have the insn_info fields
1162 initialized. However, combine deletes insns by changing them
1163 to notes. How clever. So we cannot just check if it is a
1164 valid insn before short circuiting this code, we need to see
1165 if we actually initialized it. */
1166 if (insn_info->defs)
1167 {
1168 df_mw_hardreg_chain_delete (insn_info->mw_hardregs);
1169
1170 if (df_chain)
1171 {
1172 df_ref_chain_delete_du_chain (insn_info->defs);
1173 df_ref_chain_delete_du_chain (insn_info->uses);
1174 df_ref_chain_delete_du_chain (insn_info->eq_uses);
1175 }
1176
1177 df_ref_chain_delete (insn_info->defs);
1178 df_ref_chain_delete (insn_info->uses);
1179 df_ref_chain_delete (insn_info->eq_uses);
1180 }
e011eba9 1181 pool_free (problem_data->insn_pool, insn_info);
3072d30e 1182 DF_INSN_UID_SET (uid, NULL);
e011eba9 1183 }
1184}
1185
1186
3072d30e 1187/* Free all of the refs and the mw_hardregs in COLLECTION_REC. */
d0802b39 1188
3072d30e 1189static void
1190df_free_collection_rec (struct df_collection_rec *collection_rec)
d0802b39 1191{
f7f05a07 1192 unsigned int ix;
3072d30e 1193 struct df_scan_problem_data *problem_data
1194 = (struct df_scan_problem_data *) df_scan->problem_data;
f7f05a07 1195 df_ref ref;
1196 struct df_mw_hardreg *mw;
1197
1198 for (ix = 0; VEC_iterate (df_ref, collection_rec->def_vec, ix, ref); ++ix)
1199 df_free_ref (ref);
1200 for (ix = 0; VEC_iterate (df_ref, collection_rec->use_vec, ix, ref); ++ix)
1201 df_free_ref (ref);
1202 for (ix = 0; VEC_iterate (df_ref, collection_rec->eq_use_vec, ix, ref); ++ix)
1203 df_free_ref (ref);
1204 for (ix = 0;
1205 VEC_iterate (df_mw_hardreg_ptr, collection_rec->mw_vec, ix, mw);
1206 ++ix)
1207 pool_free (problem_data->mw_reg_pool, mw);
1208
1209 VEC_free (df_ref, stack, collection_rec->def_vec);
1210 VEC_free (df_ref, stack, collection_rec->use_vec);
1211 VEC_free (df_ref, stack, collection_rec->eq_use_vec);
1212 VEC_free (df_mw_hardreg_ptr, stack, collection_rec->mw_vec);
3072d30e 1213}
d0802b39 1214
3072d30e 1215/* Rescan INSN. Return TRUE if the rescanning produced any changes. */
1216
1217bool
1218df_insn_rescan (rtx insn)
1219{
1220 unsigned int uid = INSN_UID (insn);
1221 struct df_insn_info *insn_info = NULL;
1222 basic_block bb = BLOCK_FOR_INSN (insn);
1223 struct df_collection_rec collection_rec;
3072d30e 1224
1225 if ((!df) || (!INSN_P (insn)))
1226 return false;
1227
1228 if (!bb)
d0802b39 1229 {
3072d30e 1230 if (dump_file)
1231 fprintf (dump_file, "no bb for insn with uid = %d.\n", uid);
1232 return false;
1233 }
1234
1235 /* The client has disabled rescanning and plans to do it itself. */
1236 if (df->changeable_flags & DF_NO_INSN_RESCAN)
1237 return false;
1238
1239 df_grow_bb_info (df_scan);
1240 df_grow_reg_info ();
1241
1242 insn_info = DF_INSN_UID_SAFE_GET (uid);
1243
a3de79f9 1244 /* The client has deferred rescanning. */
3072d30e 1245 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
1246 {
1247 if (!insn_info)
1248 {
1249 insn_info = df_insn_create_insn_record (insn);
1250 insn_info->defs = df_null_ref_rec;
1251 insn_info->uses = df_null_ref_rec;
1252 insn_info->eq_uses = df_null_ref_rec;
1253 insn_info->mw_hardregs = df_null_mw_rec;
1254 }
1255 if (dump_file)
bff9eb26 1256 fprintf (dump_file, "deferring rescan insn with uid = %d.\n", uid);
3072d30e 1257
1258 bitmap_clear_bit (df->insns_to_delete, uid);
1259 bitmap_clear_bit (df->insns_to_notes_rescan, uid);
1260 bitmap_set_bit (df->insns_to_rescan, INSN_UID (insn));
1261 return false;
1262 }
1263
f7f05a07 1264 collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
1265 collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
1266 collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
1267 collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
1268
3072d30e 1269 bitmap_clear_bit (df->insns_to_delete, uid);
1270 bitmap_clear_bit (df->insns_to_rescan, uid);
1271 bitmap_clear_bit (df->insns_to_notes_rescan, uid);
1272 if (insn_info)
1273 {
2e81afe5 1274 int luid;
3072d30e 1275 bool the_same = df_insn_refs_verify (&collection_rec, bb, insn, false);
1276 /* If there's no change, return false. */
1277 if (the_same)
d0802b39 1278 {
3072d30e 1279 df_free_collection_rec (&collection_rec);
1280 if (dump_file)
1281 fprintf (dump_file, "verify found no changes in insn with uid = %d.\n", uid);
1282 return false;
d0802b39 1283 }
3072d30e 1284 if (dump_file)
1285 fprintf (dump_file, "rescanning insn with uid = %d.\n", uid);
1286
2e81afe5 1287 /* There's change - we need to delete the existing info.
1288 Since the insn isn't moved, we can salvage its LUID. */
1289 luid = DF_INSN_LUID (insn);
3072d30e 1290 df_insn_delete (NULL, uid);
1291 df_insn_create_insn_record (insn);
2e81afe5 1292 DF_INSN_LUID (insn) = luid;
3072d30e 1293 }
1294 else
1295 {
158b6cc9 1296 struct df_insn_info *insn_info = df_insn_create_insn_record (insn);
1297 df_insn_refs_collect (&collection_rec, bb, insn_info);
3072d30e 1298 if (dump_file)
1299 fprintf (dump_file, "scanning new insn with uid = %d.\n", uid);
1300 }
1301
1302 df_refs_add_to_chains (&collection_rec, bb, insn);
1303 df_set_bb_dirty (bb);
f7f05a07 1304
1305 VEC_free (df_ref, stack, collection_rec.def_vec);
1306 VEC_free (df_ref, stack, collection_rec.use_vec);
1307 VEC_free (df_ref, stack, collection_rec.eq_use_vec);
1308 VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
1309
3072d30e 1310 return true;
1311}
1312
9845d120 1313/* Same as df_insn_rescan, but don't mark the basic block as
1314 dirty. */
1315
1316bool
1317df_insn_rescan_debug_internal (rtx insn)
1318{
1319 unsigned int uid = INSN_UID (insn);
1320 struct df_insn_info *insn_info;
1321
1322 gcc_assert (DEBUG_INSN_P (insn));
1323 gcc_assert (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)));
1324
1325 if (!df)
1326 return false;
1327
1328 insn_info = DF_INSN_UID_SAFE_GET (INSN_UID (insn));
1329 if (!insn_info)
1330 return false;
1331
1332 if (dump_file)
1333 fprintf (dump_file, "deleting debug_insn with uid = %d.\n", uid);
1334
1335 bitmap_clear_bit (df->insns_to_delete, uid);
1336 bitmap_clear_bit (df->insns_to_rescan, uid);
1337 bitmap_clear_bit (df->insns_to_notes_rescan, uid);
1338
1339 if (!insn_info->defs)
1340 return false;
1341
1342 if (insn_info->defs == df_null_ref_rec
1343 && insn_info->uses == df_null_ref_rec
1344 && insn_info->eq_uses == df_null_ref_rec
1345 && insn_info->mw_hardregs == df_null_mw_rec)
1346 return false;
1347
1348 df_mw_hardreg_chain_delete (insn_info->mw_hardregs);
1349
1350 if (df_chain)
1351 {
1352 df_ref_chain_delete_du_chain (insn_info->defs);
1353 df_ref_chain_delete_du_chain (insn_info->uses);
1354 df_ref_chain_delete_du_chain (insn_info->eq_uses);
1355 }
1356
1357 df_ref_chain_delete (insn_info->defs);
1358 df_ref_chain_delete (insn_info->uses);
1359 df_ref_chain_delete (insn_info->eq_uses);
1360
1361 insn_info->defs = df_null_ref_rec;
1362 insn_info->uses = df_null_ref_rec;
1363 insn_info->eq_uses = df_null_ref_rec;
1364 insn_info->mw_hardregs = df_null_mw_rec;
1365
1366 return true;
1367}
1368
3072d30e 1369
1370/* Rescan all of the insns in the function. Note that the artificial
1371 uses and defs are not touched. This function will destroy def-se
1372 or use-def chains. */
1373
1374void
1375df_insn_rescan_all (void)
1376{
1377 bool no_insn_rescan = false;
1378 bool defer_insn_rescan = false;
1379 basic_block bb;
1380 bitmap_iterator bi;
1381 unsigned int uid;
1382 bitmap tmp = BITMAP_ALLOC (&df_bitmap_obstack);
1383
1384 if (df->changeable_flags & DF_NO_INSN_RESCAN)
1385 {
1386 df_clear_flags (DF_NO_INSN_RESCAN);
1387 no_insn_rescan = true;
d0802b39 1388 }
1389
3072d30e 1390 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
d0802b39 1391 {
3072d30e 1392 df_clear_flags (DF_DEFER_INSN_RESCAN);
1393 defer_insn_rescan = true;
1394 }
1395
1396 bitmap_copy (tmp, df->insns_to_delete);
1397 EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi)
1398 {
1399 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
1400 if (insn_info)
1401 df_insn_delete (NULL, uid);
d0802b39 1402 }
3072d30e 1403
1404 BITMAP_FREE (tmp);
1405 bitmap_clear (df->insns_to_delete);
1406 bitmap_clear (df->insns_to_rescan);
1407 bitmap_clear (df->insns_to_notes_rescan);
1408
1409 FOR_EACH_BB (bb)
1410 {
1411 rtx insn;
1412 FOR_BB_INSNS (bb, insn)
1413 {
1414 df_insn_rescan (insn);
1415 }
1416 }
1417
1418 if (no_insn_rescan)
1419 df_set_flags (DF_NO_INSN_RESCAN);
1420 if (defer_insn_rescan)
1421 df_set_flags (DF_DEFER_INSN_RESCAN);
d0802b39 1422}
1423
1424
a3de79f9 1425/* Process all of the deferred rescans or deletions. */
e011eba9 1426
3072d30e 1427void
1428df_process_deferred_rescans (void)
e011eba9 1429{
3072d30e 1430 bool no_insn_rescan = false;
1431 bool defer_insn_rescan = false;
e011eba9 1432 bitmap_iterator bi;
3072d30e 1433 unsigned int uid;
1434 bitmap tmp = BITMAP_ALLOC (&df_bitmap_obstack);
1435
1436 if (df->changeable_flags & DF_NO_INSN_RESCAN)
1437 {
1438 df_clear_flags (DF_NO_INSN_RESCAN);
1439 no_insn_rescan = true;
1440 }
1441
1442 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
1443 {
1444 df_clear_flags (DF_DEFER_INSN_RESCAN);
1445 defer_insn_rescan = true;
1446 }
1447
1448 if (dump_file)
a3de79f9 1449 fprintf (dump_file, "starting the processing of deferred insns\n");
3072d30e 1450
1451 bitmap_copy (tmp, df->insns_to_delete);
1452 EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi)
1453 {
1454 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
1455 if (insn_info)
1456 df_insn_delete (NULL, uid);
1457 }
1458
1459 bitmap_copy (tmp, df->insns_to_rescan);
1460 EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi)
1461 {
1462 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
1463 if (insn_info)
1464 df_insn_rescan (insn_info->insn);
1465 }
1466
1467 bitmap_copy (tmp, df->insns_to_notes_rescan);
1468 EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi)
1469 {
1470 struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid);
1471 if (insn_info)
1472 df_notes_rescan (insn_info->insn);
1473 }
1474
1475 if (dump_file)
a3de79f9 1476 fprintf (dump_file, "ending the processing of deferred insns\n");
3072d30e 1477
1478 BITMAP_FREE (tmp);
1479 bitmap_clear (df->insns_to_delete);
1480 bitmap_clear (df->insns_to_rescan);
1481 bitmap_clear (df->insns_to_notes_rescan);
1482
1483 if (no_insn_rescan)
1484 df_set_flags (DF_NO_INSN_RESCAN);
1485 if (defer_insn_rescan)
1486 df_set_flags (DF_DEFER_INSN_RESCAN);
1487
1488 /* If someone changed regs_ever_live during this pass, fix up the
1489 entry and exit blocks. */
1490 if (df->redo_entry_and_exit)
1491 {
1492 df_update_entry_exit_and_calls ();
1493 df->redo_entry_and_exit = false;
1494 }
1495}
1496
e011eba9 1497
3072d30e 1498/* Count the number of refs. Include the defs if INCLUDE_DEFS. Include
1499 the uses if INCLUDE_USES. Include the eq_uses if
1500 INCLUDE_EQ_USES. */
1501
1502static unsigned int
1503df_count_refs (bool include_defs, bool include_uses,
1504 bool include_eq_uses)
1505{
1506 unsigned int regno;
1507 int size = 0;
1508 unsigned int m = df->regs_inited;
1509
1510 for (regno = 0; regno < m; regno++)
e011eba9 1511 {
3072d30e 1512 if (include_defs)
1513 size += DF_REG_DEF_COUNT (regno);
1514 if (include_uses)
1515 size += DF_REG_USE_COUNT (regno);
1516 if (include_eq_uses)
1517 size += DF_REG_EQ_USE_COUNT (regno);
e011eba9 1518 }
3072d30e 1519 return size;
e011eba9 1520}
1521
1522
1523/* Take build ref table for either the uses or defs from the reg-use
3072d30e 1524 or reg-def chains. This version processes the refs in reg order
1525 which is likely to be best if processing the whole function. */
e011eba9 1526
3072d30e 1527static void
1528df_reorganize_refs_by_reg_by_reg (struct df_ref_info *ref_info,
1529 bool include_defs,
1530 bool include_uses,
1531 bool include_eq_uses)
e011eba9 1532{
3072d30e 1533 unsigned int m = df->regs_inited;
e011eba9 1534 unsigned int regno;
1535 unsigned int offset = 0;
3072d30e 1536 unsigned int start;
e011eba9 1537
3072d30e 1538 if (df->changeable_flags & DF_NO_HARD_REGS)
1539 {
1540 start = FIRST_PSEUDO_REGISTER;
1541 memset (ref_info->begin, 0, sizeof (int) * FIRST_PSEUDO_REGISTER);
1542 memset (ref_info->count, 0, sizeof (int) * FIRST_PSEUDO_REGISTER);
e011eba9 1543 }
3072d30e 1544 else
1545 start = 0;
e011eba9 1546
3072d30e 1547 ref_info->total_size
1548 = df_count_refs (include_defs, include_uses, include_eq_uses);
1549
1550 df_check_and_grow_ref_info (ref_info, 1);
1551
1552 for (regno = start; regno < m; regno++)
e011eba9 1553 {
e011eba9 1554 int count = 0;
3072d30e 1555 ref_info->begin[regno] = offset;
1556 if (include_defs)
1557 {
ed6e85ae 1558 df_ref ref = DF_REG_DEF_CHAIN (regno);
3072d30e 1559 while (ref)
1560 {
1561 ref_info->refs[offset] = ref;
1562 DF_REF_ID (ref) = offset++;
1563 count++;
1564 ref = DF_REF_NEXT_REG (ref);
1565 gcc_assert (offset < ref_info->refs_size);
1566 }
1567 }
1568 if (include_uses)
e011eba9 1569 {
ed6e85ae 1570 df_ref ref = DF_REG_USE_CHAIN (regno);
e011eba9 1571 while (ref)
1572 {
1573 ref_info->refs[offset] = ref;
1574 DF_REF_ID (ref) = offset++;
3072d30e 1575 count++;
e011eba9 1576 ref = DF_REF_NEXT_REG (ref);
3072d30e 1577 gcc_assert (offset < ref_info->refs_size);
1578 }
1579 }
1580 if (include_eq_uses)
1581 {
ed6e85ae 1582 df_ref ref = DF_REG_EQ_USE_CHAIN (regno);
3072d30e 1583 while (ref)
1584 {
1585 ref_info->refs[offset] = ref;
1586 DF_REF_ID (ref) = offset++;
e011eba9 1587 count++;
3072d30e 1588 ref = DF_REF_NEXT_REG (ref);
1589 gcc_assert (offset < ref_info->refs_size);
e011eba9 1590 }
e011eba9 1591 }
3072d30e 1592 ref_info->count[regno] = count;
e011eba9 1593 }
3072d30e 1594
e011eba9 1595 /* The bitmap size is not decremented when refs are deleted. So
1596 reset it now that we have squished out all of the empty
1597 slots. */
3072d30e 1598 ref_info->table_size = offset;
e011eba9 1599}
1600
e011eba9 1601
3072d30e 1602/* Take build ref table for either the uses or defs from the reg-use
1603 or reg-def chains. This version processes the refs in insn order
1604 which is likely to be best if processing some segment of the
1605 function. */
e011eba9 1606
3072d30e 1607static void
1608df_reorganize_refs_by_reg_by_insn (struct df_ref_info *ref_info,
1609 bool include_defs,
1610 bool include_uses,
1611 bool include_eq_uses)
e011eba9 1612{
3072d30e 1613 bitmap_iterator bi;
1614 unsigned int bb_index;
1615 unsigned int m = df->regs_inited;
1616 unsigned int offset = 0;
1617 unsigned int r;
1618 unsigned int start
1619 = (df->changeable_flags & DF_NO_HARD_REGS) ? FIRST_PSEUDO_REGISTER : 0;
e011eba9 1620
3072d30e 1621 memset (ref_info->begin, 0, sizeof (int) * df->regs_inited);
1622 memset (ref_info->count, 0, sizeof (int) * df->regs_inited);
1623
1624 ref_info->total_size = df_count_refs (include_defs, include_uses, include_eq_uses);
1625 df_check_and_grow_ref_info (ref_info, 1);
e011eba9 1626
3072d30e 1627 EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, bb_index, bi)
e011eba9 1628 {
3072d30e 1629 basic_block bb = BASIC_BLOCK (bb_index);
1630 rtx insn;
ed6e85ae 1631 df_ref *ref_rec;
3072d30e 1632
1633 if (include_defs)
1634 for (ref_rec = df_get_artificial_defs (bb_index); *ref_rec; ref_rec++)
3e6933a8 1635 {
3072d30e 1636 unsigned int regno = DF_REF_REGNO (*ref_rec);
1637 ref_info->count[regno]++;
3e6933a8 1638 }
3072d30e 1639 if (include_uses)
1640 for (ref_rec = df_get_artificial_uses (bb_index); *ref_rec; ref_rec++)
3e6933a8 1641 {
3072d30e 1642 unsigned int regno = DF_REF_REGNO (*ref_rec);
1643 ref_info->count[regno]++;
3e6933a8 1644 }
e011eba9 1645
3072d30e 1646 FOR_BB_INSNS (bb, insn)
1647 {
1648 if (INSN_P (insn))
1649 {
1650 unsigned int uid = INSN_UID (insn);
1651
1652 if (include_defs)
1653 for (ref_rec = DF_INSN_UID_DEFS (uid); *ref_rec; ref_rec++)
1654 {
1655 unsigned int regno = DF_REF_REGNO (*ref_rec);
1656 ref_info->count[regno]++;
1657 }
1658 if (include_uses)
1659 for (ref_rec = DF_INSN_UID_USES (uid); *ref_rec; ref_rec++)
1660 {
1661 unsigned int regno = DF_REF_REGNO (*ref_rec);
1662 ref_info->count[regno]++;
1663 }
1664 if (include_eq_uses)
1665 for (ref_rec = DF_INSN_UID_EQ_USES (uid); *ref_rec; ref_rec++)
1666 {
1667 unsigned int regno = DF_REF_REGNO (*ref_rec);
1668 ref_info->count[regno]++;
1669 }
1670 }
1671 }
1672 }
1673
1674 for (r = start; r < m; r++)
1675 {
1676 ref_info->begin[r] = offset;
1677 offset += ref_info->count[r];
1678 ref_info->count[r] = 0;
1679 }
1680
1681 EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, bb_index, bi)
1682 {
1683 basic_block bb = BASIC_BLOCK (bb_index);
1684 rtx insn;
ed6e85ae 1685 df_ref *ref_rec;
3072d30e 1686
1687 if (include_defs)
1688 for (ref_rec = df_get_artificial_defs (bb_index); *ref_rec; ref_rec++)
3e6933a8 1689 {
ed6e85ae 1690 df_ref ref = *ref_rec;
3072d30e 1691 unsigned int regno = DF_REF_REGNO (ref);
1692 if (regno >= start)
3e6933a8 1693 {
3072d30e 1694 unsigned int id
1695 = ref_info->begin[regno] + ref_info->count[regno]++;
1696 DF_REF_ID (ref) = id;
1697 ref_info->refs[id] = ref;
3e6933a8 1698 }
3e6933a8 1699 }
3072d30e 1700 if (include_uses)
1701 for (ref_rec = df_get_artificial_uses (bb_index); *ref_rec; ref_rec++)
3e6933a8 1702 {
ed6e85ae 1703 df_ref ref = *ref_rec;
3072d30e 1704 unsigned int regno = DF_REF_REGNO (ref);
1705 if (regno >= start)
1706 {
1707 unsigned int id
1708 = ref_info->begin[regno] + ref_info->count[regno]++;
1709 DF_REF_ID (ref) = id;
1710 ref_info->refs[id] = ref;
1711 }
3e6933a8 1712 }
3072d30e 1713
1714 FOR_BB_INSNS (bb, insn)
1715 {
1716 if (INSN_P (insn))
1717 {
1718 unsigned int uid = INSN_UID (insn);
1719
1720 if (include_defs)
1721 for (ref_rec = DF_INSN_UID_DEFS (uid); *ref_rec; ref_rec++)
1722 {
ed6e85ae 1723 df_ref ref = *ref_rec;
3072d30e 1724 unsigned int regno = DF_REF_REGNO (ref);
1725 if (regno >= start)
1726 {
1727 unsigned int id
1728 = ref_info->begin[regno] + ref_info->count[regno]++;
1729 DF_REF_ID (ref) = id;
1730 ref_info->refs[id] = ref;
1731 }
1732 }
1733 if (include_uses)
1734 for (ref_rec = DF_INSN_UID_USES (uid); *ref_rec; ref_rec++)
1735 {
ed6e85ae 1736 df_ref ref = *ref_rec;
3072d30e 1737 unsigned int regno = DF_REF_REGNO (ref);
1738 if (regno >= start)
1739 {
1740 unsigned int id
1741 = ref_info->begin[regno] + ref_info->count[regno]++;
1742 DF_REF_ID (ref) = id;
1743 ref_info->refs[id] = ref;
1744 }
1745 }
1746 if (include_eq_uses)
1747 for (ref_rec = DF_INSN_UID_EQ_USES (uid); *ref_rec; ref_rec++)
1748 {
ed6e85ae 1749 df_ref ref = *ref_rec;
3072d30e 1750 unsigned int regno = DF_REF_REGNO (ref);
1751 if (regno >= start)
1752 {
1753 unsigned int id
1754 = ref_info->begin[regno] + ref_info->count[regno]++;
1755 DF_REF_ID (ref) = id;
1756 ref_info->refs[id] = ref;
1757 }
1758 }
1759 }
1760 }
1761 }
1762
1763 /* The bitmap size is not decremented when refs are deleted. So
1764 reset it now that we have squished out all of the empty
1765 slots. */
1766
1767 ref_info->table_size = offset;
1768}
1769
1770/* Take build ref table for either the uses or defs from the reg-use
1771 or reg-def chains. */
1772
1773static void
1774df_reorganize_refs_by_reg (struct df_ref_info *ref_info,
1775 bool include_defs,
1776 bool include_uses,
1777 bool include_eq_uses)
1778{
1779 if (df->analyze_subset)
1780 df_reorganize_refs_by_reg_by_insn (ref_info, include_defs,
1781 include_uses, include_eq_uses);
1782 else
1783 df_reorganize_refs_by_reg_by_reg (ref_info, include_defs,
1784 include_uses, include_eq_uses);
1785}
1786
1787
1788/* Add the refs in REF_VEC to the table in REF_INFO starting at OFFSET. */
1789static unsigned int
1790df_add_refs_to_table (unsigned int offset,
1791 struct df_ref_info *ref_info,
ed6e85ae 1792 df_ref *ref_vec)
3072d30e 1793{
1794 while (*ref_vec)
1795 {
ed6e85ae 1796 df_ref ref = *ref_vec;
3072d30e 1797 if ((!(df->changeable_flags & DF_NO_HARD_REGS))
1798 || (DF_REF_REGNO (ref) >= FIRST_PSEUDO_REGISTER))
1799 {
1800 ref_info->refs[offset] = ref;
1801 DF_REF_ID (*ref_vec) = offset++;
1802 }
1803 ref_vec++;
1804 }
1805 return offset;
1806}
1807
1808
1809/* Count the number of refs in all of the insns of BB. Include the
1810 defs if INCLUDE_DEFS. Include the uses if INCLUDE_USES. Include the
1811 eq_uses if INCLUDE_EQ_USES. */
1812
1813static unsigned int
1814df_reorganize_refs_by_insn_bb (basic_block bb, unsigned int offset,
1815 struct df_ref_info *ref_info,
1816 bool include_defs, bool include_uses,
1817 bool include_eq_uses)
1818{
1819 rtx insn;
1820
1821 if (include_defs)
1822 offset = df_add_refs_to_table (offset, ref_info,
1823 df_get_artificial_defs (bb->index));
1824 if (include_uses)
1825 offset = df_add_refs_to_table (offset, ref_info,
1826 df_get_artificial_uses (bb->index));
1827
1828 FOR_BB_INSNS (bb, insn)
1829 if (INSN_P (insn))
1830 {
1831 unsigned int uid = INSN_UID (insn);
1832 if (include_defs)
1833 offset = df_add_refs_to_table (offset, ref_info,
1834 DF_INSN_UID_DEFS (uid));
1835 if (include_uses)
1836 offset = df_add_refs_to_table (offset, ref_info,
1837 DF_INSN_UID_USES (uid));
1838 if (include_eq_uses)
1839 offset = df_add_refs_to_table (offset, ref_info,
1840 DF_INSN_UID_EQ_USES (uid));
3e6933a8 1841 }
3072d30e 1842 return offset;
1843}
1844
1845
bef304b8 1846/* Organize the refs by insn into the table in REF_INFO. If
3072d30e 1847 blocks_to_analyze is defined, use that set, otherwise the entire
1848 program. Include the defs if INCLUDE_DEFS. Include the uses if
1849 INCLUDE_USES. Include the eq_uses if INCLUDE_EQ_USES. */
1850
1851static void
1852df_reorganize_refs_by_insn (struct df_ref_info *ref_info,
1853 bool include_defs, bool include_uses,
1854 bool include_eq_uses)
1855{
1856 basic_block bb;
1857 unsigned int offset = 0;
1858
1859 ref_info->total_size = df_count_refs (include_defs, include_uses, include_eq_uses);
1860 df_check_and_grow_ref_info (ref_info, 1);
1861 if (df->blocks_to_analyze)
1862 {
1863 bitmap_iterator bi;
1864 unsigned int index;
1865
1866 EXECUTE_IF_SET_IN_BITMAP (df->blocks_to_analyze, 0, index, bi)
1867 {
1868 offset = df_reorganize_refs_by_insn_bb (BASIC_BLOCK (index), offset, ref_info,
1869 include_defs, include_uses,
1870 include_eq_uses);
1871 }
1872
1873 ref_info->table_size = offset;
1874 }
1875 else
1876 {
1877 FOR_ALL_BB (bb)
1878 offset = df_reorganize_refs_by_insn_bb (bb, offset, ref_info,
1879 include_defs, include_uses,
1880 include_eq_uses);
1881 ref_info->table_size = offset;
1882 }
1883}
1884
1885
1886/* If the use refs in DF are not organized, reorganize them. */
1887
1888void
1889df_maybe_reorganize_use_refs (enum df_ref_order order)
1890{
1891 if (order == df->use_info.ref_order)
1892 return;
1893
1894 switch (order)
1895 {
1896 case DF_REF_ORDER_BY_REG:
1897 df_reorganize_refs_by_reg (&df->use_info, false, true, false);
1898 break;
1899
1900 case DF_REF_ORDER_BY_REG_WITH_NOTES:
1901 df_reorganize_refs_by_reg (&df->use_info, false, true, true);
1902 break;
1903
1904 case DF_REF_ORDER_BY_INSN:
1905 df_reorganize_refs_by_insn (&df->use_info, false, true, false);
1906 break;
1907
1908 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
1909 df_reorganize_refs_by_insn (&df->use_info, false, true, true);
1910 break;
1911
1912 case DF_REF_ORDER_NO_TABLE:
1913 free (df->use_info.refs);
1914 df->use_info.refs = NULL;
1915 df->use_info.refs_size = 0;
1916 break;
1917
1918 case DF_REF_ORDER_UNORDERED:
1919 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
1920 gcc_unreachable ();
1921 break;
1922 }
1923
1924 df->use_info.ref_order = order;
1925}
1926
1927
1928/* If the def refs in DF are not organized, reorganize them. */
1929
1930void
1931df_maybe_reorganize_def_refs (enum df_ref_order order)
1932{
1933 if (order == df->def_info.ref_order)
1934 return;
1935
1936 switch (order)
1937 {
1938 case DF_REF_ORDER_BY_REG:
1939 df_reorganize_refs_by_reg (&df->def_info, true, false, false);
1940 break;
1941
1942 case DF_REF_ORDER_BY_INSN:
1943 df_reorganize_refs_by_insn (&df->def_info, true, false, false);
1944 break;
1945
1946 case DF_REF_ORDER_NO_TABLE:
1947 free (df->def_info.refs);
1948 df->def_info.refs = NULL;
1949 df->def_info.refs_size = 0;
1950 break;
1951
1952 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
1953 case DF_REF_ORDER_BY_REG_WITH_NOTES:
1954 case DF_REF_ORDER_UNORDERED:
1955 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
1956 gcc_unreachable ();
1957 break;
1958 }
1959
1960 df->def_info.ref_order = order;
1961}
1962
1963
3072d30e 1964/* Change all of the basic block references in INSN to use the insn's
1965 current basic block. This function is called from routines that move
1966 instructions from one block to another. */
1967
1968void
a2bdd643 1969df_insn_change_bb (rtx insn, basic_block new_bb)
3072d30e 1970{
a2bdd643 1971 basic_block old_bb = BLOCK_FOR_INSN (insn);
3072d30e 1972 struct df_insn_info *insn_info;
1973 unsigned int uid = INSN_UID (insn);
1974
a2bdd643 1975 if (old_bb == new_bb)
1976 return;
1977
1978 set_block_for_insn (insn, new_bb);
1979
3072d30e 1980 if (!df)
1981 return;
1982
1983 if (dump_file)
1984 fprintf (dump_file, "changing bb of uid %d\n", uid);
1985
1986 insn_info = DF_INSN_UID_SAFE_GET (uid);
1987 if (insn_info == NULL)
1988 {
1989 if (dump_file)
1990 fprintf (dump_file, " unscanned insn\n");
1991 df_insn_rescan (insn);
1992 return;
1993 }
1994
1995 if (!INSN_P (insn))
1996 return;
1997
3072d30e 1998 df_set_bb_dirty (new_bb);
1999 if (old_bb)
2000 {
2001 if (dump_file)
2002 fprintf (dump_file, " from %d to %d\n",
2003 old_bb->index, new_bb->index);
2004 df_set_bb_dirty (old_bb);
2005 }
2006 else
2007 if (dump_file)
2008 fprintf (dump_file, " to %d\n", new_bb->index);
2009}
2010
2011
2012/* Helper function for df_ref_change_reg_with_loc. */
2013
2014static void
ed6e85ae 2015df_ref_change_reg_with_loc_1 (struct df_reg_info *old_df,
2016 struct df_reg_info *new_df,
3072d30e 2017 int new_regno, rtx loc)
2018{
ed6e85ae 2019 df_ref the_ref = old_df->reg_chain;
3072d30e 2020
2021 while (the_ref)
2022 {
ed6e85ae 2023 if ((!DF_REF_IS_ARTIFICIAL (the_ref))
2024 && (DF_REF_LOC (the_ref))
2025 && (*DF_REF_LOC (the_ref) == loc))
3072d30e 2026 {
ed6e85ae 2027 df_ref next_ref = DF_REF_NEXT_REG (the_ref);
2028 df_ref prev_ref = DF_REF_PREV_REG (the_ref);
2029 df_ref *ref_vec, *ref_vec_t;
2030 struct df_insn_info *insn_info = DF_REF_INSN_INFO (the_ref);
3072d30e 2031 unsigned int count = 0;
2032
2033 DF_REF_REGNO (the_ref) = new_regno;
2034 DF_REF_REG (the_ref) = regno_reg_rtx[new_regno];
2035
2036 /* Pull the_ref out of the old regno chain. */
2037 if (prev_ref)
ed6e85ae 2038 DF_REF_NEXT_REG (prev_ref) = next_ref;
3072d30e 2039 else
9ce37fa7 2040 old_df->reg_chain = next_ref;
3072d30e 2041 if (next_ref)
ed6e85ae 2042 DF_REF_PREV_REG (next_ref) = prev_ref;
9ce37fa7 2043 old_df->n_refs--;
3072d30e 2044
2045 /* Put the ref into the new regno chain. */
ed6e85ae 2046 DF_REF_PREV_REG (the_ref) = NULL;
2047 DF_REF_NEXT_REG (the_ref) = new_df->reg_chain;
9ce37fa7 2048 if (new_df->reg_chain)
ed6e85ae 2049 DF_REF_PREV_REG (new_df->reg_chain) = the_ref;
9ce37fa7 2050 new_df->reg_chain = the_ref;
2051 new_df->n_refs++;
a43c254c 2052 if (DF_REF_BB (the_ref))
2053 df_set_bb_dirty (DF_REF_BB (the_ref));
3072d30e 2054
ed6e85ae 2055 /* Need to sort the record again that the ref was in because
2056 the regno is a sorting key. First, find the right
2057 record. */
2058 if (DF_REF_FLAGS (the_ref) & DF_REF_IN_NOTE)
2059 ref_vec = insn_info->eq_uses;
3072d30e 2060 else
ed6e85ae 2061 ref_vec = insn_info->uses;
2062 if (dump_file)
2063 fprintf (dump_file, "changing reg in insn %d\n",
2064 DF_REF_INSN_UID (the_ref));
2065
3072d30e 2066 ref_vec_t = ref_vec;
ed6e85ae 2067
3072d30e 2068 /* Find the length. */
2069 while (*ref_vec_t)
2070 {
2071 count++;
2072 ref_vec_t++;
2073 }
ed6e85ae 2074 qsort (ref_vec, count, sizeof (df_ref ), df_ref_compare);
3072d30e 2075
2076 the_ref = next_ref;
2077 }
2078 else
ed6e85ae 2079 the_ref = DF_REF_NEXT_REG (the_ref);
3072d30e 2080 }
2081}
2082
2083
2084/* Change the regno of all refs that contained LOC from OLD_REGNO to
ed6e85ae 2085 NEW_REGNO. Refs that do not match LOC are not changed which means
2086 that artificial refs are not changed since they have no loc. This
2087 call is to support the SET_REGNO macro. */
3072d30e 2088
2089void
2090df_ref_change_reg_with_loc (int old_regno, int new_regno, rtx loc)
2091{
2092 if ((!df) || (old_regno == -1) || (old_regno == new_regno))
2093 return;
2094
2095 df_grow_reg_info ();
2096
2097 df_ref_change_reg_with_loc_1 (DF_REG_DEF_GET (old_regno),
2098 DF_REG_DEF_GET (new_regno), new_regno, loc);
2099 df_ref_change_reg_with_loc_1 (DF_REG_USE_GET (old_regno),
2100 DF_REG_USE_GET (new_regno), new_regno, loc);
2101 df_ref_change_reg_with_loc_1 (DF_REG_EQ_USE_GET (old_regno),
2102 DF_REG_EQ_USE_GET (new_regno), new_regno, loc);
2103}
2104
2105
2106/* Delete the mw_hardregs that point into the eq_notes. */
2107
2108static unsigned int
2109df_mw_hardreg_chain_delete_eq_uses (struct df_insn_info *insn_info)
2110{
2111 struct df_mw_hardreg **mw_vec = insn_info->mw_hardregs;
2112 unsigned int deleted = 0;
2113 unsigned int count = 0;
2114 struct df_scan_problem_data *problem_data
2115 = (struct df_scan_problem_data *) df_scan->problem_data;
2116
2117 if (!*mw_vec)
2118 return 0;
2119
2120 while (*mw_vec)
2121 {
2122 if ((*mw_vec)->flags & DF_REF_IN_NOTE)
2123 {
2124 struct df_mw_hardreg **temp_vec = mw_vec;
2125
2126 pool_free (problem_data->mw_reg_pool, *mw_vec);
2127 temp_vec = mw_vec;
2128 /* Shove the remaining ones down one to fill the gap. While
2129 this looks n**2, it is highly unusual to have any mw regs
2130 in eq_notes and the chances of more than one are almost
2131 non existent. */
2132 while (*temp_vec)
2133 {
2134 *temp_vec = *(temp_vec + 1);
2135 temp_vec++;
2136 }
2137 deleted++;
2138 }
2139 else
2140 {
2141 mw_vec++;
2142 count++;
2143 }
2144 }
2145
2146 if (count == 0)
2147 {
ce299759 2148 df_scan_free_mws_vec (insn_info->mw_hardregs);
3072d30e 2149 insn_info->mw_hardregs = df_null_mw_rec;
2150 return 0;
2151 }
2152 return deleted;
2153}
2154
2155
2156/* Rescan only the REG_EQUIV/REG_EQUAL notes part of INSN. */
2157
2158void
2159df_notes_rescan (rtx insn)
2160{
2161 struct df_insn_info *insn_info;
2162 unsigned int uid = INSN_UID (insn);
2163
2164 if (!df)
2165 return;
2166
2167 /* The client has disabled rescanning and plans to do it itself. */
2168 if (df->changeable_flags & DF_NO_INSN_RESCAN)
2169 return;
2170
3e3659e7 2171 /* Do nothing if the insn hasn't been emitted yet. */
2172 if (!BLOCK_FOR_INSN (insn))
2173 return;
2174
3072d30e 2175 df_grow_bb_info (df_scan);
2176 df_grow_reg_info ();
2177
2178 insn_info = DF_INSN_UID_SAFE_GET (INSN_UID(insn));
2179
a3de79f9 2180 /* The client has deferred rescanning. */
3072d30e 2181 if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
2182 {
2183 if (!insn_info)
2184 {
2185 insn_info = df_insn_create_insn_record (insn);
2186 insn_info->defs = df_null_ref_rec;
2187 insn_info->uses = df_null_ref_rec;
2188 insn_info->eq_uses = df_null_ref_rec;
2189 insn_info->mw_hardregs = df_null_mw_rec;
2190 }
2191
2192 bitmap_clear_bit (df->insns_to_delete, uid);
2193 /* If the insn is set to be rescanned, it does not need to also
2194 be notes rescanned. */
2195 if (!bitmap_bit_p (df->insns_to_rescan, uid))
2196 bitmap_set_bit (df->insns_to_notes_rescan, INSN_UID (insn));
2197 return;
2198 }
2199
2200 bitmap_clear_bit (df->insns_to_delete, uid);
2201 bitmap_clear_bit (df->insns_to_notes_rescan, uid);
2202
2203 if (insn_info)
2204 {
2205 basic_block bb = BLOCK_FOR_INSN (insn);
2206 rtx note;
2207 struct df_collection_rec collection_rec;
2208 unsigned int num_deleted;
f7f05a07 2209 unsigned int mw_len;
3072d30e 2210
2211 memset (&collection_rec, 0, sizeof (struct df_collection_rec));
f7f05a07 2212 collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
2213 collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
3072d30e 2214
2215 num_deleted = df_mw_hardreg_chain_delete_eq_uses (insn_info);
2216 df_ref_chain_delete (insn_info->eq_uses);
2217 insn_info->eq_uses = NULL;
2218
2219 /* Process REG_EQUIV/REG_EQUAL notes */
2220 for (note = REG_NOTES (insn); note;
2221 note = XEXP (note, 1))
2222 {
2223 switch (REG_NOTE_KIND (note))
2224 {
2225 case REG_EQUIV:
2226 case REG_EQUAL:
ed6e85ae 2227 df_uses_record (DF_REF_REGULAR, &collection_rec,
3072d30e 2228 &XEXP (note, 0), DF_REF_REG_USE,
b9c74b4d 2229 bb, insn_info, DF_REF_IN_NOTE, -1, -1, VOIDmode);
3072d30e 2230 default:
2231 break;
2232 }
2233 }
2234
2235 /* Find some place to put any new mw_hardregs. */
2236 df_canonize_collection_rec (&collection_rec);
f7f05a07 2237 mw_len = VEC_length (df_mw_hardreg_ptr, collection_rec.mw_vec);
2238 if (mw_len)
3072d30e 2239 {
2240 unsigned int count = 0;
2241 struct df_mw_hardreg **mw_rec = insn_info->mw_hardregs;
2242 while (*mw_rec)
2243 {
2244 count++;
2245 mw_rec++;
2246 }
2247
2248 if (count)
2249 {
2250 /* Append to the end of the existing record after
2251 expanding it if necessary. */
f7f05a07 2252 if (mw_len > num_deleted)
3072d30e 2253 {
2254 insn_info->mw_hardregs =
c768b48b 2255 XRESIZEVEC (struct df_mw_hardreg *,
f7f05a07 2256 insn_info->mw_hardregs,
2257 count + 1 + mw_len);
3072d30e 2258 }
f7f05a07 2259 memcpy (&insn_info->mw_hardregs[count],
2260 VEC_address (df_mw_hardreg_ptr, collection_rec.mw_vec),
2261 mw_len * sizeof (struct df_mw_hardreg *));
2262 insn_info->mw_hardregs[count + mw_len] = NULL;
2263 qsort (insn_info->mw_hardregs, count + mw_len,
3072d30e 2264 sizeof (struct df_mw_hardreg *), df_mw_compare);
2265 }
2266 else
2267 {
2268 /* No vector there. */
2269 insn_info->mw_hardregs
f7f05a07 2270 = XNEWVEC (struct df_mw_hardreg*, 1 + mw_len);
2271 memcpy (insn_info->mw_hardregs,
2272 VEC_address (df_mw_hardreg_ptr, collection_rec.mw_vec),
2273 mw_len * sizeof (struct df_mw_hardreg *));
2274 insn_info->mw_hardregs[mw_len] = NULL;
3072d30e 2275 }
2276 }
2277 /* Get rid of the mw_rec so that df_refs_add_to_chains will
2278 ignore it. */
f7f05a07 2279 VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
3072d30e 2280 df_refs_add_to_chains (&collection_rec, bb, insn);
f7f05a07 2281 VEC_free (df_ref, stack, collection_rec.eq_use_vec);
3072d30e 2282 }
2283 else
2284 df_insn_rescan (insn);
2285
2286}
2287
2288\f
2289/*----------------------------------------------------------------------------
2290 Hard core instruction scanning code. No external interfaces here,
2291 just a lot of routines that look inside insns.
2292----------------------------------------------------------------------------*/
2293
2294
2295/* Return true if the contents of two df_ref's are identical.
2296 It ignores DF_REF_MARKER. */
2297
2298static bool
ed6e85ae 2299df_ref_equal_p (df_ref ref1, df_ref ref2)
3072d30e 2300{
2301 if (!ref2)
2302 return false;
ed6e85ae 2303
2304 if (ref1 == ref2)
2305 return true;
2306
2307 if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2)
2308 || DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2)
2309 || DF_REF_REG (ref1) != DF_REF_REG (ref2)
2310 || DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2)
2311 || ((DF_REF_FLAGS (ref1) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG))
2312 != (DF_REF_FLAGS (ref2) & ~(DF_REF_REG_MARKER + DF_REF_MW_HARDREG)))
2313 || DF_REF_BB (ref1) != DF_REF_BB (ref2)
2314 || DF_REF_INSN_INFO (ref1) != DF_REF_INSN_INFO (ref2))
2315 return false;
2316
2317 switch (DF_REF_CLASS (ref1))
2318 {
2319 case DF_REF_ARTIFICIAL:
2320 case DF_REF_BASE:
2321 return true;
30de5b55 2322
ed6e85ae 2323 case DF_REF_EXTRACT:
2324 if ((DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
bf1f8fbc 2325 || (DF_REF_EXTRACT_WIDTH (ref1) != DF_REF_EXTRACT_WIDTH (ref2))
ed6e85ae 2326 || (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2)))
2327 return false;
2328 /* fallthru. */
2329
2330 case DF_REF_REGULAR:
2331 return DF_REF_LOC (ref1) == DF_REF_LOC (ref2);
30de5b55 2332
ed6e85ae 2333 default:
2334 gcc_unreachable ();
2335 }
2336 return false;
3072d30e 2337}
2338
2339
2340/* Compare REF1 and REF2 for sorting. This is only called from places
2341 where all of the refs are of the same type, in the same insn, and
2342 have the same bb. So these fields are not checked. */
2343
2344static int
2345df_ref_compare (const void *r1, const void *r2)
2346{
ed6e85ae 2347 const df_ref ref1 = *(const df_ref *)r1;
2348 const df_ref ref2 = *(const df_ref *)r2;
3072d30e 2349
2350 if (ref1 == ref2)
2351 return 0;
2352
ed6e85ae 2353 if (DF_REF_CLASS (ref1) != DF_REF_CLASS (ref2))
2354 return (int)DF_REF_CLASS (ref1) - (int)DF_REF_CLASS (ref2);
2355
3072d30e 2356 if (DF_REF_REGNO (ref1) != DF_REF_REGNO (ref2))
2357 return (int)DF_REF_REGNO (ref1) - (int)DF_REF_REGNO (ref2);
2358
2359 if (DF_REF_TYPE (ref1) != DF_REF_TYPE (ref2))
2360 return (int)DF_REF_TYPE (ref1) - (int)DF_REF_TYPE (ref2);
2361
ed6e85ae 2362 if (DF_REF_REG (ref1) != DF_REF_REG (ref2))
2363 return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
2364
2365 /* Cannot look at the LOC field on artificial refs. */
2366 if (DF_REF_CLASS (ref1) != DF_REF_ARTIFICIAL
2367 && DF_REF_LOC (ref1) != DF_REF_LOC (ref2))
3072d30e 2368 return (int)DF_REF_ORDER (ref1) - (int)DF_REF_ORDER (ref2);
2369
2370 if (DF_REF_FLAGS (ref1) != DF_REF_FLAGS (ref2))
2371 {
2372 /* If two refs are identical except that one of them has is from
2373 a mw and one is not, we need to have the one with the mw
2374 first. */
2375 if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_MW_HARDREG) ==
2376 DF_REF_FLAGS_IS_SET (ref2, DF_REF_MW_HARDREG))
2377 return DF_REF_FLAGS (ref1) - DF_REF_FLAGS (ref2);
2378 else if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_MW_HARDREG))
2379 return -1;
2380 else
2381 return 1;
2382 }
30de5b55 2383
ed6e85ae 2384 /* The classes are the same at this point so it is safe to only look
30de5b55 2385 at ref1. */
ed6e85ae 2386 if (DF_REF_CLASS (ref1) == DF_REF_EXTRACT)
30de5b55 2387 {
ed6e85ae 2388 if (DF_REF_EXTRACT_OFFSET (ref1) != DF_REF_EXTRACT_OFFSET (ref2))
2389 return DF_REF_EXTRACT_OFFSET (ref1) - DF_REF_EXTRACT_OFFSET (ref2);
2390 if (DF_REF_EXTRACT_WIDTH (ref1) != DF_REF_EXTRACT_WIDTH (ref2))
2391 return DF_REF_EXTRACT_WIDTH (ref1) - DF_REF_EXTRACT_WIDTH (ref2);
2392 if (DF_REF_EXTRACT_MODE (ref1) != DF_REF_EXTRACT_MODE (ref2))
2393 return DF_REF_EXTRACT_MODE (ref1) - DF_REF_EXTRACT_MODE (ref2);
30de5b55 2394 }
3072d30e 2395 return 0;
2396}
2397
2398static void
f7f05a07 2399df_swap_refs (VEC(df_ref,stack) **ref_vec, int i, int j)
3072d30e 2400{
f7f05a07 2401 df_ref tmp = VEC_index (df_ref, *ref_vec, i);
2402 VEC_replace (df_ref, *ref_vec, i, VEC_index (df_ref, *ref_vec, j));
2403 VEC_replace (df_ref, *ref_vec, j, tmp);
3072d30e 2404}
2405
2406/* Sort and compress a set of refs. */
2407
f7f05a07 2408static void
2409df_sort_and_compress_refs (VEC(df_ref,stack) **ref_vec)
3072d30e 2410{
f7f05a07 2411 unsigned int count;
3072d30e 2412 unsigned int i;
2413 unsigned int dist = 0;
2414
f7f05a07 2415 count = VEC_length (df_ref, *ref_vec);
2416
3072d30e 2417 /* If there are 1 or 0 elements, there is nothing to do. */
2418 if (count < 2)
f7f05a07 2419 return;
3072d30e 2420 else if (count == 2)
2421 {
f7f05a07 2422 df_ref r0 = VEC_index (df_ref, *ref_vec, 0);
2423 df_ref r1 = VEC_index (df_ref, *ref_vec, 1);
2424 if (df_ref_compare (&r0, &r1) > 0)
3072d30e 2425 df_swap_refs (ref_vec, 0, 1);
2426 }
2427 else
2428 {
2429 for (i = 0; i < count - 1; i++)
f7f05a07 2430 {
2431 df_ref r0 = VEC_index (df_ref, *ref_vec, i);
2432 df_ref r1 = VEC_index (df_ref, *ref_vec, i + 1);
2433 if (df_ref_compare (&r0, &r1) >= 0)
2434 break;
2435 }
3072d30e 2436 /* If the array is already strictly ordered,
2437 which is the most common case for large COUNT case
2438 (which happens for CALL INSNs),
2439 no need to sort and filter out duplicate.
2440 Simply return the count.
2441 Make sure DF_GET_ADD_REFS adds refs in the increasing order
2442 of DF_REF_COMPARE. */
2443 if (i == count - 1)
f7f05a07 2444 return;
2445 qsort (VEC_address (df_ref, *ref_vec), count, sizeof (df_ref),
2446 df_ref_compare);
3072d30e 2447 }
2448
2449 for (i=0; i<count-dist; i++)
2450 {
2451 /* Find the next ref that is not equal to the current ref. */
f7f05a07 2452 while (i + dist + 1 < count
2453 && df_ref_equal_p (VEC_index (df_ref, *ref_vec, i),
2454 VEC_index (df_ref, *ref_vec, i + dist + 1)))
3072d30e 2455 {
f7f05a07 2456 df_free_ref (VEC_index (df_ref, *ref_vec, i + dist + 1));
3072d30e 2457 dist++;
2458 }
2459 /* Copy it down to the next position. */
f7f05a07 2460 if (dist && i + dist + 1 < count)
2461 VEC_replace (df_ref, *ref_vec, i + 1,
2462 VEC_index (df_ref, *ref_vec, i + dist + 1));
3072d30e 2463 }
2464
2465 count -= dist;
f7f05a07 2466 VEC_truncate (df_ref, *ref_vec, count);
3072d30e 2467}
2468
2469
2470/* Return true if the contents of two df_ref's are identical.
2471 It ignores DF_REF_MARKER. */
2472
2473static bool
2474df_mw_equal_p (struct df_mw_hardreg *mw1, struct df_mw_hardreg *mw2)
2475{
2476 if (!mw2)
2477 return false;
2478 return (mw1 == mw2) ||
2479 (mw1->mw_reg == mw2->mw_reg
2480 && mw1->type == mw2->type
2481 && mw1->flags == mw2->flags
2482 && mw1->start_regno == mw2->start_regno
2483 && mw1->end_regno == mw2->end_regno);
2484}
2485
2486
2487/* Compare MW1 and MW2 for sorting. */
2488
2489static int
2490df_mw_compare (const void *m1, const void *m2)
2491{
c1fdef8e 2492 const struct df_mw_hardreg *const mw1 = *(const struct df_mw_hardreg *const*)m1;
2493 const struct df_mw_hardreg *const mw2 = *(const struct df_mw_hardreg *const*)m2;
3072d30e 2494
2495 if (mw1 == mw2)
2496 return 0;
2497
2498 if (mw1->type != mw2->type)
2499 return mw1->type - mw2->type;
2500
2501 if (mw1->flags != mw2->flags)
2502 return mw1->flags - mw2->flags;
2503
2504 if (mw1->start_regno != mw2->start_regno)
2505 return mw1->start_regno - mw2->start_regno;
2506
2507 if (mw1->end_regno != mw2->end_regno)
2508 return mw1->end_regno - mw2->end_regno;
2509
2510 if (mw1->mw_reg != mw2->mw_reg)
2511 return mw1->mw_order - mw2->mw_order;
2512
2513 return 0;
2514}
2515
2516
2517/* Sort and compress a set of refs. */
2518
f7f05a07 2519static void
2520df_sort_and_compress_mws (VEC(df_mw_hardreg_ptr,stack) **mw_vec)
3072d30e 2521{
f7f05a07 2522 unsigned int count;
3072d30e 2523 struct df_scan_problem_data *problem_data
2524 = (struct df_scan_problem_data *) df_scan->problem_data;
2525 unsigned int i;
2526 unsigned int dist = 0;
3072d30e 2527
f7f05a07 2528 count = VEC_length (df_mw_hardreg_ptr, *mw_vec);
3072d30e 2529 if (count < 2)
f7f05a07 2530 return;
3072d30e 2531 else if (count == 2)
2532 {
f7f05a07 2533 struct df_mw_hardreg *m0 = VEC_index (df_mw_hardreg_ptr, *mw_vec, 0);
2534 struct df_mw_hardreg *m1 = VEC_index (df_mw_hardreg_ptr, *mw_vec, 1);
2535 if (df_mw_compare (&m0, &m1) > 0)
3072d30e 2536 {
f7f05a07 2537 struct df_mw_hardreg *tmp = VEC_index (df_mw_hardreg_ptr,
2538 *mw_vec, 0);
2539 VEC_replace (df_mw_hardreg_ptr, *mw_vec, 0,
2540 VEC_index (df_mw_hardreg_ptr, *mw_vec, 1));
2541 VEC_replace (df_mw_hardreg_ptr, *mw_vec, 1, tmp);
3072d30e 2542 }
2543 }
2544 else
f7f05a07 2545 qsort (VEC_address (df_mw_hardreg_ptr, *mw_vec), count,
2546 sizeof (struct df_mw_hardreg *), df_mw_compare);
3072d30e 2547
2548 for (i=0; i<count-dist; i++)
2549 {
2550 /* Find the next ref that is not equal to the current ref. */
f7f05a07 2551 while (i + dist + 1 < count
2552 && df_mw_equal_p (VEC_index (df_mw_hardreg_ptr, *mw_vec, i),
2553 VEC_index (df_mw_hardreg_ptr, *mw_vec,
2554 i + dist + 1)))
3072d30e 2555 {
f7f05a07 2556 pool_free (problem_data->mw_reg_pool,
2557 VEC_index (df_mw_hardreg_ptr, *mw_vec, i + dist + 1));
3072d30e 2558 dist++;
2559 }
2560 /* Copy it down to the next position. */
f7f05a07 2561 if (dist && i + dist + 1 < count)
2562 VEC_replace (df_mw_hardreg_ptr, *mw_vec, i + 1,
2563 VEC_index (df_mw_hardreg_ptr, *mw_vec, i + dist + 1));
3072d30e 2564 }
2565
2566 count -= dist;
f7f05a07 2567 VEC_truncate (df_mw_hardreg_ptr, *mw_vec, count);
3072d30e 2568}
2569
2570
2571/* Sort and remove duplicates from the COLLECTION_REC. */
2572
2573static void
2574df_canonize_collection_rec (struct df_collection_rec *collection_rec)
2575{
f7f05a07 2576 df_sort_and_compress_refs (&collection_rec->def_vec);
2577 df_sort_and_compress_refs (&collection_rec->use_vec);
2578 df_sort_and_compress_refs (&collection_rec->eq_use_vec);
2579 df_sort_and_compress_mws (&collection_rec->mw_vec);
3072d30e 2580}
2581
2582
2583/* Add the new df_ref to appropriate reg_info/ref_info chains. */
2584
2585static void
ed6e85ae 2586df_install_ref (df_ref this_ref,
3072d30e 2587 struct df_reg_info *reg_info,
2588 struct df_ref_info *ref_info,
2589 bool add_to_table)
2590{
2591 unsigned int regno = DF_REF_REGNO (this_ref);
2592 /* Add the ref to the reg_{def,use,eq_use} chain. */
ed6e85ae 2593 df_ref head = reg_info->reg_chain;
3072d30e 2594
2595 reg_info->reg_chain = this_ref;
2596 reg_info->n_refs++;
2597
2598 if (DF_REF_FLAGS_IS_SET (this_ref, DF_HARD_REG_LIVE))
2599 {
2600 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
2601 df->hard_regs_live_count[regno]++;
2602 }
2603
2604 gcc_assert (DF_REF_NEXT_REG (this_ref) == NULL);
2605 gcc_assert (DF_REF_PREV_REG (this_ref) == NULL);
2606
2607 DF_REF_NEXT_REG (this_ref) = head;
2608
2609 /* We cannot actually link to the head of the chain. */
2610 DF_REF_PREV_REG (this_ref) = NULL;
2611
2612 if (head)
2613 DF_REF_PREV_REG (head) = this_ref;
2614
2615 if (add_to_table)
2616 {
2617 gcc_assert (ref_info->ref_order != DF_REF_ORDER_NO_TABLE);
2618 df_check_and_grow_ref_info (ref_info, 1);
2619 DF_REF_ID (this_ref) = ref_info->table_size;
2620 /* Add the ref to the big array of defs. */
2621 ref_info->refs[ref_info->table_size] = this_ref;
2622 ref_info->table_size++;
2623 }
2624 else
2625 DF_REF_ID (this_ref) = -1;
2626
2627 ref_info->total_size++;
2628}
2629
2630
2631/* This function takes one of the groups of refs (defs, uses or
2632 eq_uses) and installs the entire group into the insn. It also adds
2633 each of these refs into the appropriate chains. */
2634
ed6e85ae 2635static df_ref *
3072d30e 2636df_install_refs (basic_block bb,
f7f05a07 2637 VEC(df_ref,stack)* old_vec,
3072d30e 2638 struct df_reg_info **reg_info,
2639 struct df_ref_info *ref_info,
2640 bool is_notes)
2641{
f7f05a07 2642 unsigned int count;
2643
2644 count = VEC_length (df_ref, old_vec);
3072d30e 2645 if (count)
2646 {
ed6e85ae 2647 df_ref *new_vec = XNEWVEC (df_ref, count + 1);
3072d30e 2648 bool add_to_table;
f7f05a07 2649 df_ref this_ref;
2650 unsigned int ix;
3072d30e 2651
2652 switch (ref_info->ref_order)
2653 {
2654 case DF_REF_ORDER_UNORDERED_WITH_NOTES:
2655 case DF_REF_ORDER_BY_REG_WITH_NOTES:
2656 case DF_REF_ORDER_BY_INSN_WITH_NOTES:
2657 ref_info->ref_order = DF_REF_ORDER_UNORDERED_WITH_NOTES;
2658 add_to_table = true;
2659 break;
2660 case DF_REF_ORDER_UNORDERED:
2661 case DF_REF_ORDER_BY_REG:
2662 case DF_REF_ORDER_BY_INSN:
2663 ref_info->ref_order = DF_REF_ORDER_UNORDERED;
2664 add_to_table = !is_notes;
2665 break;
2666 default:
2667 add_to_table = false;
2668 break;
2669 }
2670
2671 /* Do not add if ref is not in the right blocks. */
2672 if (add_to_table && df->analyze_subset)
2673 add_to_table = bitmap_bit_p (df->blocks_to_analyze, bb->index);
2674
f7f05a07 2675 for (ix = 0; VEC_iterate (df_ref, old_vec, ix, this_ref); ++ix)
3072d30e 2676 {
f7f05a07 2677 new_vec[ix] = this_ref;
3072d30e 2678 df_install_ref (this_ref, reg_info[DF_REF_REGNO (this_ref)],
2679 ref_info, add_to_table);
2680 }
2681
2682 new_vec[count] = NULL;
2683 return new_vec;
2684 }
2685 else
2686 return df_null_ref_rec;
2687}
2688
2689
2690/* This function takes the mws installs the entire group into the
2691 insn. */
2692
2693static struct df_mw_hardreg **
f7f05a07 2694df_install_mws (VEC(df_mw_hardreg_ptr,stack) *old_vec)
3072d30e 2695{
f7f05a07 2696 unsigned int count;
2697
2698 count = VEC_length (df_mw_hardreg_ptr, old_vec);
3072d30e 2699 if (count)
2700 {
2701 struct df_mw_hardreg **new_vec
2702 = XNEWVEC (struct df_mw_hardreg*, count + 1);
f7f05a07 2703 memcpy (new_vec, VEC_address (df_mw_hardreg_ptr, old_vec),
2704 sizeof (struct df_mw_hardreg*) * count);
2705 new_vec[count] = NULL;
3072d30e 2706 return new_vec;
2707 }
2708 else
2709 return df_null_mw_rec;
2710}
2711
2712
2713/* Add a chain of df_refs to appropriate ref chain/reg_info/ref_info
2714 chains and update other necessary information. */
2715
2716static void
2717df_refs_add_to_chains (struct df_collection_rec *collection_rec,
2718 basic_block bb, rtx insn)
2719{
2720 if (insn)
2721 {
158b6cc9 2722 struct df_insn_info *insn_rec = DF_INSN_INFO_GET (insn);
3072d30e 2723 /* If there is a vector in the collection rec, add it to the
2724 insn. A null rec is a signal that the caller will handle the
2725 chain specially. */
2726 if (collection_rec->def_vec)
2727 {
ce299759 2728 df_scan_free_ref_vec (insn_rec->defs);
3072d30e 2729 insn_rec->defs
f7f05a07 2730 = df_install_refs (bb, collection_rec->def_vec,
3072d30e 2731 df->def_regs,
2732 &df->def_info, false);
2733 }
2734 if (collection_rec->use_vec)
2735 {
ce299759 2736 df_scan_free_ref_vec (insn_rec->uses);
3072d30e 2737 insn_rec->uses
2738 = df_install_refs (bb, collection_rec->use_vec,
3072d30e 2739 df->use_regs,
2740 &df->use_info, false);
2741 }
2742 if (collection_rec->eq_use_vec)
2743 {
ce299759 2744 df_scan_free_ref_vec (insn_rec->eq_uses);
3072d30e 2745 insn_rec->eq_uses
2746 = df_install_refs (bb, collection_rec->eq_use_vec,
3072d30e 2747 df->eq_use_regs,
2748 &df->use_info, true);
2749 }
2750 if (collection_rec->mw_vec)
2751 {
ce299759 2752 df_scan_free_mws_vec (insn_rec->mw_hardregs);
3072d30e 2753 insn_rec->mw_hardregs
f7f05a07 2754 = df_install_mws (collection_rec->mw_vec);
3072d30e 2755 }
2756 }
2757 else
2758 {
2759 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb->index);
2760
ce299759 2761 df_scan_free_ref_vec (bb_info->artificial_defs);
3072d30e 2762 bb_info->artificial_defs
f7f05a07 2763 = df_install_refs (bb, collection_rec->def_vec,
3072d30e 2764 df->def_regs,
2765 &df->def_info, false);
ce299759 2766 df_scan_free_ref_vec (bb_info->artificial_uses);
3072d30e 2767 bb_info->artificial_uses
2768 = df_install_refs (bb, collection_rec->use_vec,
3072d30e 2769 df->use_regs,
2770 &df->use_info, false);
2771 }
2772}
e011eba9 2773
e011eba9 2774
30de5b55 2775/* Allocate a ref and initialize its fields.
2776
2777 If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
bf1f8fbc 2778 DF_REF_ZERO_EXTRACT. WIDTH, OFFSET and MODE are used to access the fields
30de5b55 2779 if they were constants. Otherwise they should be -1 if those flags
2780 were set. */
3072d30e 2781
ed6e85ae 2782static df_ref
2783df_ref_create_structure (enum df_ref_class cl,
2784 struct df_collection_rec *collection_rec,
3072d30e 2785 rtx reg, rtx *loc,
158b6cc9 2786 basic_block bb, struct df_insn_info *info,
3072d30e 2787 enum df_ref_type ref_type,
b9c74b4d 2788 int ref_flags,
bf1f8fbc 2789 int width, int offset, enum machine_mode mode)
3072d30e 2790{
ed6e85ae 2791 df_ref this_ref = NULL;
3072d30e 2792 int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
2793 struct df_scan_problem_data *problem_data
2794 = (struct df_scan_problem_data *) df_scan->problem_data;
2795
ed6e85ae 2796 switch (cl)
30de5b55 2797 {
ed6e85ae 2798 case DF_REF_BASE:
2799 this_ref = (df_ref) pool_alloc (problem_data->ref_base_pool);
2800 gcc_assert (loc == NULL);
2801 break;
2802
2803 case DF_REF_ARTIFICIAL:
2804 this_ref = (df_ref) pool_alloc (problem_data->ref_artificial_pool);
2805 this_ref->artificial_ref.bb = bb;
2806 gcc_assert (loc == NULL);
2807 break;
2808
2809 case DF_REF_REGULAR:
2810 this_ref = (df_ref) pool_alloc (problem_data->ref_regular_pool);
2811 this_ref->regular_ref.loc = loc;
2812 gcc_assert (loc);
2813 break;
2814
2815 case DF_REF_EXTRACT:
2816 this_ref = (df_ref) pool_alloc (problem_data->ref_extract_pool);
bf1f8fbc 2817 DF_REF_EXTRACT_WIDTH (this_ref) = width;
2818 DF_REF_EXTRACT_OFFSET (this_ref) = offset;
2819 DF_REF_EXTRACT_MODE (this_ref) = mode;
ed6e85ae 2820 this_ref->regular_ref.loc = loc;
2821 gcc_assert (loc);
2822 break;
30de5b55 2823 }
ed6e85ae 2824
2825 DF_REF_CLASS (this_ref) = cl;
3072d30e 2826 DF_REF_ID (this_ref) = -1;
2827 DF_REF_REG (this_ref) = reg;
2828 DF_REF_REGNO (this_ref) = regno;
ed6e85ae 2829 DF_REF_TYPE (this_ref) = ref_type;
158b6cc9 2830 DF_REF_INSN_INFO (this_ref) = info;
3072d30e 2831 DF_REF_CHAIN (this_ref) = NULL;
3072d30e 2832 DF_REF_FLAGS (this_ref) = ref_flags;
3072d30e 2833 DF_REF_NEXT_REG (this_ref) = NULL;
2834 DF_REF_PREV_REG (this_ref) = NULL;
2835 DF_REF_ORDER (this_ref) = df->ref_order++;
2836
2837 /* We need to clear this bit because fwprop, and in the future
2838 possibly other optimizations sometimes create new refs using ond
2839 refs as the model. */
2840 DF_REF_FLAGS_CLEAR (this_ref, DF_HARD_REG_LIVE);
2841
2842 /* See if this ref needs to have DF_HARD_REG_LIVE bit set. */
2843 if ((regno < FIRST_PSEUDO_REGISTER)
2844 && (!DF_REF_IS_ARTIFICIAL (this_ref)))
2845 {
ed6e85ae 2846 if (DF_REF_REG_DEF_P (this_ref))
3072d30e 2847 {
2848 if (!DF_REF_FLAGS_IS_SET (this_ref, DF_REF_MAY_CLOBBER))
2849 DF_REF_FLAGS_SET (this_ref, DF_HARD_REG_LIVE);
2850 }
2851 else if (!(TEST_HARD_REG_BIT (elim_reg_set, regno)
2852 && (regno == FRAME_POINTER_REGNUM
2853 || regno == ARG_POINTER_REGNUM)))
2854 DF_REF_FLAGS_SET (this_ref, DF_HARD_REG_LIVE);
2855 }
2856
2857 if (collection_rec)
2858 {
ed6e85ae 2859 if (DF_REF_REG_DEF_P (this_ref))
f7f05a07 2860 VEC_safe_push (df_ref, stack, collection_rec->def_vec, this_ref);
3072d30e 2861 else if (DF_REF_FLAGS (this_ref) & DF_REF_IN_NOTE)
f7f05a07 2862 VEC_safe_push (df_ref, stack, collection_rec->eq_use_vec, this_ref);
3072d30e 2863 else
f7f05a07 2864 VEC_safe_push (df_ref, stack, collection_rec->use_vec, this_ref);
e011eba9 2865 }
3072d30e 2866
e011eba9 2867 return this_ref;
2868}
2869
2870
2871/* Create new references of type DF_REF_TYPE for each part of register REG
30de5b55 2872 at address LOC within INSN of BB.
2873
2874 If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
bf1f8fbc 2875 DF_REF_ZERO_EXTRACT. WIDTH, OFFSET and MODE are used to access the
2876 fields if they were constants. Otherwise they should be -1 if
2877 those flags were set. */
30de5b55 2878
e011eba9 2879
2880static void
ed6e85ae 2881df_ref_record (enum df_ref_class cl,
2882 struct df_collection_rec *collection_rec,
3072d30e 2883 rtx reg, rtx *loc,
158b6cc9 2884 basic_block bb, struct df_insn_info *insn_info,
e011eba9 2885 enum df_ref_type ref_type,
b9c74b4d 2886 int ref_flags,
bf1f8fbc 2887 int width, int offset, enum machine_mode mode)
e011eba9 2888{
3e6933a8 2889 unsigned int regno;
e011eba9 2890
2891 gcc_assert (REG_P (reg) || GET_CODE (reg) == SUBREG);
2892
e011eba9 2893 regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg);
2894 if (regno < FIRST_PSEUDO_REGISTER)
2895 {
3e6933a8 2896 struct df_mw_hardreg *hardreg = NULL;
2897 struct df_scan_problem_data *problem_data
3072d30e 2898 = (struct df_scan_problem_data *) df_scan->problem_data;
2899 unsigned int i;
2900 unsigned int endregno;
ed6e85ae 2901 df_ref ref;
e011eba9 2902
e011eba9 2903 if (GET_CODE (reg) == SUBREG)
fe2ebfc8 2904 {
2905 regno += subreg_regno_offset (regno, GET_MODE (SUBREG_REG (reg)),
2906 SUBREG_BYTE (reg), GET_MODE (reg));
a2c6f0b7 2907 endregno = regno + subreg_nregs (reg);
fe2ebfc8 2908 }
2909 else
a2c6f0b7 2910 endregno = END_HARD_REGNO (reg);
e011eba9 2911
3072d30e 2912 /* If this is a multiword hardreg, we create some extra
2913 datastructures that will enable us to easily build REG_DEAD
2914 and REG_UNUSED notes. */
158b6cc9 2915 if ((endregno != regno + 1) && insn_info)
3e6933a8 2916 {
3e6933a8 2917 /* Sets to a subreg of a multiword register are partial.
2918 Sets to a non-subreg of a multiword register are not. */
05beda33 2919 if (GET_CODE (reg) == SUBREG)
3e6933a8 2920 ref_flags |= DF_REF_PARTIAL;
2921 ref_flags |= DF_REF_MW_HARDREG;
3072d30e 2922
364c0c59 2923 hardreg = (struct df_mw_hardreg *) pool_alloc (problem_data->mw_reg_pool);
3e6933a8 2924 hardreg->type = ref_type;
2925 hardreg->flags = ref_flags;
2926 hardreg->mw_reg = reg;
3072d30e 2927 hardreg->start_regno = regno;
2928 hardreg->end_regno = endregno - 1;
2929 hardreg->mw_order = df->ref_order++;
f7f05a07 2930 VEC_safe_push (df_mw_hardreg_ptr, stack, collection_rec->mw_vec,
2931 hardreg);
3e6933a8 2932 }
2933
e011eba9 2934 for (i = regno; i < endregno; i++)
2935 {
ed6e85ae 2936 ref = df_ref_create_structure (cl, collection_rec, regno_reg_rtx[i], loc,
158b6cc9 2937 bb, insn_info, ref_type, ref_flags,
bf1f8fbc 2938 width, offset, mode);
3e6933a8 2939
3072d30e 2940 gcc_assert (ORIGINAL_REGNO (DF_REF_REG (ref)) == i);
e011eba9 2941 }
2942 }
2943 else
2944 {
ed6e85ae 2945 df_ref_create_structure (cl, collection_rec, reg, loc, bb, insn_info,
2946 ref_type, ref_flags, width, offset, mode);
e011eba9 2947 }
2948}
2949
2950
2951/* A set to a non-paradoxical SUBREG for which the number of word_mode units
2952 covered by the outer mode is smaller than that covered by the inner mode,
2953 is a read-modify-write operation.
2954 This function returns true iff the SUBREG X is such a SUBREG. */
2955
2956bool
2957df_read_modify_subreg_p (rtx x)
2958{
2959 unsigned int isize, osize;
2960 if (GET_CODE (x) != SUBREG)
2961 return false;
2962 isize = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
2963 osize = GET_MODE_SIZE (GET_MODE (x));
c9a4672f 2964 return isize > osize
2965 && isize > REGMODE_NATURAL_SIZE (GET_MODE (SUBREG_REG (x)));
e011eba9 2966}
2967
2968
2969/* Process all the registers defined in the rtx, X.
2970 Autoincrement/decrement definitions will be picked up by
2971 df_uses_record. */
2972
2973static void
3072d30e 2974df_def_record_1 (struct df_collection_rec *collection_rec,
158b6cc9 2975 rtx x, basic_block bb, struct df_insn_info *insn_info,
b9c74b4d 2976 int flags)
e011eba9 2977{
2978 rtx *loc;
2979 rtx dst;
30de5b55 2980 int offset = -1;
2981 int width = -1;
bc620c5c 2982 enum machine_mode mode = VOIDmode;
ed6e85ae 2983 enum df_ref_class cl = DF_REF_REGULAR;
e011eba9 2984
2985 /* We may recursively call ourselves on EXPR_LIST when dealing with PARALLEL
2986 construct. */
2987 if (GET_CODE (x) == EXPR_LIST || GET_CODE (x) == CLOBBER)
2988 loc = &XEXP (x, 0);
2989 else
2990 loc = &SET_DEST (x);
2991 dst = *loc;
2992
35792caf 2993 /* It is legal to have a set destination be a parallel. */
2994 if (GET_CODE (dst) == PARALLEL)
e011eba9 2995 {
2996 int i;
2997
2998 for (i = XVECLEN (dst, 0) - 1; i >= 0; i--)
2999 {
3000 rtx temp = XVECEXP (dst, 0, i);
3001 if (GET_CODE (temp) == EXPR_LIST || GET_CODE (temp) == CLOBBER
3002 || GET_CODE (temp) == SET)
3072d30e 3003 df_def_record_1 (collection_rec,
158b6cc9 3004 temp, bb, insn_info,
3e6933a8 3005 GET_CODE (temp) == CLOBBER
3072d30e 3006 ? flags | DF_REF_MUST_CLOBBER : flags);
e011eba9 3007 }
3008 return;
3009 }
3010
30de5b55 3011 if (GET_CODE (dst) == STRICT_LOW_PART)
e011eba9 3012 {
30de5b55 3013 flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_STRICT_LOW_PART;
3014
3015 loc = &XEXP (dst, 0);
3016 dst = *loc;
3017 }
3018
3019 if (GET_CODE (dst) == ZERO_EXTRACT)
3020 {
3021 flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_ZERO_EXTRACT;
3022
971ba038 3023 if (CONST_INT_P (XEXP (dst, 1))
3024 && CONST_INT_P (XEXP (dst, 2)))
30de5b55 3025 {
3026 width = INTVAL (XEXP (dst, 1));
3027 offset = INTVAL (XEXP (dst, 2));
bf1f8fbc 3028 mode = GET_MODE (dst);
ed6e85ae 3029 cl = DF_REF_EXTRACT;
30de5b55 3030 }
dea7b504 3031
e011eba9 3032 loc = &XEXP (dst, 0);
3033 dst = *loc;
e011eba9 3034 }
3035
dea7b504 3036 /* At this point if we do not have a reg or a subreg, just return. */
3037 if (REG_P (dst))
3038 {
ed6e85ae 3039 df_ref_record (cl, collection_rec,
158b6cc9 3040 dst, loc, bb, insn_info, DF_REF_REG_DEF, flags,
bf1f8fbc 3041 width, offset, mode);
dea7b504 3042
3043 /* We want to keep sp alive everywhere - by making all
3044 writes to sp also use of sp. */
3045 if (REGNO (dst) == STACK_POINTER_REGNUM)
ed6e85ae 3046 df_ref_record (DF_REF_BASE, collection_rec,
158b6cc9 3047 dst, NULL, bb, insn_info, DF_REF_REG_USE, flags,
bf1f8fbc 3048 width, offset, mode);
dea7b504 3049 }
3050 else if (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst)))
3051 {
3052 if (df_read_modify_subreg_p (dst))
3053 flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL;
c9a4672f 3054
dea7b504 3055 flags |= DF_REF_SUBREG;
37ad3318 3056
ed6e85ae 3057 df_ref_record (cl, collection_rec,
158b6cc9 3058 dst, loc, bb, insn_info, DF_REF_REG_DEF, flags,
bf1f8fbc 3059 width, offset, mode);
dea7b504 3060 }
e011eba9 3061}
3062
3063
3064/* Process all the registers defined in the pattern rtx, X. */
3065
3066static void
3072d30e 3067df_defs_record (struct df_collection_rec *collection_rec,
158b6cc9 3068 rtx x, basic_block bb, struct df_insn_info *insn_info,
b9c74b4d 3069 int flags)
e011eba9 3070{
3071 RTX_CODE code = GET_CODE (x);
3072
3073 if (code == SET || code == CLOBBER)
3074 {
3075 /* Mark the single def within the pattern. */
8458f4ca 3076 int clobber_flags = flags;
3072d30e 3077 clobber_flags |= (code == CLOBBER) ? DF_REF_MUST_CLOBBER : 0;
158b6cc9 3078 df_def_record_1 (collection_rec, x, bb, insn_info, clobber_flags);
e011eba9 3079 }
3080 else if (code == COND_EXEC)
3081 {
3072d30e 3082 df_defs_record (collection_rec, COND_EXEC_CODE (x),
158b6cc9 3083 bb, insn_info, DF_REF_CONDITIONAL);
e011eba9 3084 }
3085 else if (code == PARALLEL)
3086 {
3087 int i;
3088
3089 /* Mark the multiple defs within the pattern. */
3090 for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
158b6cc9 3091 df_defs_record (collection_rec, XVECEXP (x, 0, i), bb, insn_info, flags);
e011eba9 3092 }
3093}
3094
3095
30de5b55 3096/* Process all the registers used in the rtx at address LOC.
3097
3098 If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or
bf1f8fbc 3099 DF_REF_ZERO_EXTRACT. WIDTH, OFFSET and MODE are used to access the
3100 fields if they were constants. Otherwise they should be -1 if
3101 those flags were set. */
e011eba9 3102
3103static void
ed6e85ae 3104df_uses_record (enum df_ref_class cl, struct df_collection_rec *collection_rec,
3072d30e 3105 rtx *loc, enum df_ref_type ref_type,
158b6cc9 3106 basic_block bb, struct df_insn_info *insn_info,
b9c74b4d 3107 int flags,
bf1f8fbc 3108 int width, int offset, enum machine_mode mode)
e011eba9 3109{
3110 RTX_CODE code;
3111 rtx x;
3072d30e 3112
e011eba9 3113 retry:
3114 x = *loc;
3115 if (!x)
3116 return;
3117 code = GET_CODE (x);
3118 switch (code)
3119 {
3120 case LABEL_REF:
3121 case SYMBOL_REF:
3122 case CONST_INT:
3123 case CONST:
3124 case CONST_DOUBLE:
e397ad8e 3125 case CONST_FIXED:
e011eba9 3126 case CONST_VECTOR:
3127 case PC:
3128 case CC0:
3129 case ADDR_VEC:
3130 case ADDR_DIFF_VEC:
3131 return;
3132
3133 case CLOBBER:
3134 /* If we are clobbering a MEM, mark any registers inside the address
3135 as being used. */
3136 if (MEM_P (XEXP (x, 0)))
ed6e85ae 3137 df_uses_record (cl, collection_rec,
3072d30e 3138 &XEXP (XEXP (x, 0), 0),
158b6cc9 3139 DF_REF_REG_MEM_STORE,
3140 bb, insn_info,
3141 flags, width, offset, mode);
e011eba9 3142
3143 /* If we're clobbering a REG then we have a def so ignore. */
3144 return;
3145
3146 case MEM:
ed6e85ae 3147 df_uses_record (cl, collection_rec,
3072d30e 3148 &XEXP (x, 0), DF_REF_REG_MEM_LOAD,
158b6cc9 3149 bb, insn_info, flags & DF_REF_IN_NOTE,
bf1f8fbc 3150 width, offset, mode);
e011eba9 3151 return;
3152
3153 case SUBREG:
3154 /* While we're here, optimize this case. */
3e6933a8 3155 flags |= DF_REF_PARTIAL;
e011eba9 3156 /* In case the SUBREG is not of a REG, do not optimize. */
3157 if (!REG_P (SUBREG_REG (x)))
3158 {
3159 loc = &SUBREG_REG (x);
ed6e85ae 3160 df_uses_record (cl, collection_rec, loc, ref_type, bb, insn_info, flags,
bf1f8fbc 3161 width, offset, mode);
e011eba9 3162 return;
3163 }
3164 /* ... Fall through ... */
3165
3166 case REG:
ed6e85ae 3167 df_ref_record (cl, collection_rec,
158b6cc9 3168 x, loc, bb, insn_info,
3169 ref_type, flags,
bf1f8fbc 3170 width, offset, mode);
e011eba9 3171 return;
3172
30de5b55 3173 case SIGN_EXTRACT:
3174 case ZERO_EXTRACT:
3175 {
3176 /* If the parameters to the zero or sign extract are
3177 constants, strip them off and recurse, otherwise there is
3178 no information that we can gain from this operation. */
971ba038 3179 if (CONST_INT_P (XEXP (x, 1))
3180 && CONST_INT_P (XEXP (x, 2)))
30de5b55 3181 {
3182 width = INTVAL (XEXP (x, 1));
3183 offset = INTVAL (XEXP (x, 2));
bf1f8fbc 3184 mode = GET_MODE (x);
30de5b55 3185
3186 if (code == ZERO_EXTRACT)
3187 flags |= DF_REF_ZERO_EXTRACT;
3188 else
3189 flags |= DF_REF_SIGN_EXTRACT;
3190
ed6e85ae 3191 df_uses_record (DF_REF_EXTRACT, collection_rec,
158b6cc9 3192 &XEXP (x, 0), ref_type, bb, insn_info, flags,
bf1f8fbc 3193 width, offset, mode);
30de5b55 3194 return;
3195 }
3196 }
3197 break;
3198
e011eba9 3199 case SET:
3200 {
3201 rtx dst = SET_DEST (x);
3202 gcc_assert (!(flags & DF_REF_IN_NOTE));
ed6e85ae 3203 df_uses_record (cl, collection_rec,
158b6cc9 3204 &SET_SRC (x), DF_REF_REG_USE, bb, insn_info, flags,
bf1f8fbc 3205 width, offset, mode);
e011eba9 3206
3207 switch (GET_CODE (dst))
3208 {
3209 case SUBREG:
3210 if (df_read_modify_subreg_p (dst))
3211 {
ed6e85ae 3212 df_uses_record (cl, collection_rec, &SUBREG_REG (dst),
158b6cc9 3213 DF_REF_REG_USE, bb, insn_info,
bf1f8fbc 3214 flags | DF_REF_READ_WRITE | DF_REF_SUBREG,
3215 width, offset, mode);
e011eba9 3216 break;
3217 }
3218 /* Fall through. */
3219 case REG:
3220 case PARALLEL:
3221 case SCRATCH:
3222 case PC:
3223 case CC0:
3224 break;
3225 case MEM:
ed6e85ae 3226 df_uses_record (cl, collection_rec, &XEXP (dst, 0),
158b6cc9 3227 DF_REF_REG_MEM_STORE, bb, insn_info, flags,
bf1f8fbc 3228 width, offset, mode);
e011eba9 3229 break;
3230 case STRICT_LOW_PART:
3231 {
3232 rtx *temp = &XEXP (dst, 0);
3233 /* A strict_low_part uses the whole REG and not just the
3234 SUBREG. */
3235 dst = XEXP (dst, 0);
ed6e85ae 3236 df_uses_record (cl, collection_rec,
3072d30e 3237 (GET_CODE (dst) == SUBREG) ? &SUBREG_REG (dst) : temp,
158b6cc9 3238 DF_REF_REG_USE, bb, insn_info,
bf1f8fbc 3239 DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART,
3240 width, offset, mode);
e011eba9 3241 }
3242 break;
3243 case ZERO_EXTRACT:
30de5b55 3244 {
971ba038 3245 if (CONST_INT_P (XEXP (dst, 1))
3246 && CONST_INT_P (XEXP (dst, 2)))
30de5b55 3247 {
3248 width = INTVAL (XEXP (dst, 1));
3249 offset = INTVAL (XEXP (dst, 2));
bf1f8fbc 3250 mode = GET_MODE (dst);
f5109c63 3251 if (GET_CODE (XEXP (dst,0)) == MEM)
3252 {
3253 /* Handle the case of zero_extract(mem(...)) in the set dest.
3254 This special case is allowed only if the mem is a single byte and
3255 is useful to set a bitfield in memory. */
3256 df_uses_record (DF_REF_EXTRACT, collection_rec, &XEXP (XEXP (dst,0), 0),
3257 DF_REF_REG_MEM_STORE, bb, insn_info,
3258 DF_REF_ZERO_EXTRACT,
3259 width, offset, mode);
3260 }
3261 else
3262 {
3263 df_uses_record (DF_REF_EXTRACT, collection_rec, &XEXP (dst, 0),
3264 DF_REF_REG_USE, bb, insn_info,
3265 DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
3266 width, offset, mode);
3267 }
30de5b55 3268 }
3269 else
3270 {
ed6e85ae 3271 df_uses_record (cl, collection_rec, &XEXP (dst, 1),
158b6cc9 3272 DF_REF_REG_USE, bb, insn_info, flags,
bf1f8fbc 3273 width, offset, mode);
ed6e85ae 3274 df_uses_record (cl, collection_rec, &XEXP (dst, 2),
158b6cc9 3275 DF_REF_REG_USE, bb, insn_info, flags,
bf1f8fbc 3276 width, offset, mode);
ed6e85ae 3277 df_uses_record (cl, collection_rec, &XEXP (dst, 0),
3278 DF_REF_REG_USE, bb, insn_info,
3279 DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT,
3280 width, offset, mode);
30de5b55 3281 }
3282
30de5b55 3283 }
e011eba9 3284 break;
30de5b55 3285
e011eba9 3286 default:
3287 gcc_unreachable ();
3288 }
3289 return;
3290 }
3291
3292 case RETURN:
3293 break;
3294
3295 case ASM_OPERANDS:
3296 case UNSPEC_VOLATILE:
3297 case TRAP_IF:
3298 case ASM_INPUT:
3299 {
3300 /* Traditional and volatile asm instructions must be
3301 considered to use and clobber all hard registers, all
3302 pseudo-registers and all of memory. So must TRAP_IF and
3303 UNSPEC_VOLATILE operations.
3304
3305 Consider for instance a volatile asm that changes the fpu
3306 rounding mode. An insn should not be moved across this
3307 even if it only uses pseudo-regs because it might give an
3308 incorrectly rounded result.
3309
3310 However, flow.c's liveness computation did *not* do this,
3311 giving the reasoning as " ?!? Unfortunately, marking all
3312 hard registers as live causes massive problems for the
3313 register allocator and marking all pseudos as live creates
3314 mountains of uninitialized variable warnings."
3315
3316 In order to maintain the status quo with regard to liveness
3317 and uses, we do what flow.c did and just mark any regs we
3072d30e 3318 can find in ASM_OPERANDS as used. In global asm insns are
3319 scanned and regs_asm_clobbered is filled out.
e011eba9 3320
3321 For all ASM_OPERANDS, we must traverse the vector of input
3322 operands. We can not just fall through here since then we
3323 would be confused by the ASM_INPUT rtx inside ASM_OPERANDS,
3324 which do not indicate traditional asms unlike their normal
3325 usage. */
3326 if (code == ASM_OPERANDS)
3327 {
3328 int j;
3329
3330 for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
ed6e85ae 3331 df_uses_record (cl, collection_rec, &ASM_OPERANDS_INPUT (x, j),
158b6cc9 3332 DF_REF_REG_USE, bb, insn_info, flags,
bf1f8fbc 3333 width, offset, mode);
e011eba9 3334 return;
3335 }
3336 break;
3337 }
3338
9845d120 3339 case VAR_LOCATION:
3340 df_uses_record (cl, collection_rec,
3341 &PAT_VAR_LOCATION_LOC (x),
3342 DF_REF_REG_USE, bb, insn_info,
3343 flags, width, offset, mode);
3344 return;
3345
e011eba9 3346 case PRE_DEC:
3347 case POST_DEC:
3348 case PRE_INC:
3349 case POST_INC:
3350 case PRE_MODIFY:
3351 case POST_MODIFY:
9845d120 3352 gcc_assert (!DEBUG_INSN_P (insn_info->insn));
e011eba9 3353 /* Catch the def of the register being modified. */
ed6e85ae 3354 df_ref_record (cl, collection_rec, XEXP (x, 0), &XEXP (x, 0),
158b6cc9 3355 bb, insn_info,
7577c7f7 3356 DF_REF_REG_DEF,
bf1f8fbc 3357 flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY,
3358 width, offset, mode);
e011eba9 3359
3360 /* ... Fall through to handle uses ... */
3361
3362 default:
3363 break;
3364 }
3365
3366 /* Recursively scan the operands of this expression. */
3367 {
3368 const char *fmt = GET_RTX_FORMAT (code);
3369 int i;
3370
3371 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3372 {
3373 if (fmt[i] == 'e')
3374 {
3375 /* Tail recursive case: save a function call level. */
3376 if (i == 0)
3377 {
3378 loc = &XEXP (x, 0);
3379 goto retry;
3380 }
ed6e85ae 3381 df_uses_record (cl, collection_rec, &XEXP (x, i), ref_type,
158b6cc9 3382 bb, insn_info, flags,
bf1f8fbc 3383 width, offset, mode);
e011eba9 3384 }
3385 else if (fmt[i] == 'E')
3386 {
3387 int j;
3388 for (j = 0; j < XVECLEN (x, i); j++)
ed6e85ae 3389 df_uses_record (cl, collection_rec,
30de5b55 3390 &XVECEXP (x, i, j), ref_type,
158b6cc9 3391 bb, insn_info, flags,
bf1f8fbc 3392 width, offset, mode);
e011eba9 3393 }
3394 }
3395 }
e011eba9 3396
3072d30e 3397 return;
e011eba9 3398}
3399
3400
3072d30e 3401/* For all DF_REF_CONDITIONAL defs, add a corresponding uses. */
e011eba9 3402
3072d30e 3403static void
3404df_get_conditional_uses (struct df_collection_rec *collection_rec)
e011eba9 3405{
f7f05a07 3406 unsigned int ix;
3407 df_ref ref;
3408
3409 for (ix = 0; VEC_iterate (df_ref, collection_rec->def_vec, ix, ref); ++ix)
3072d30e 3410 {
3072d30e 3411 if (DF_REF_FLAGS_IS_SET (ref, DF_REF_CONDITIONAL))
3412 {
30de5b55 3413 int width = -1;
3414 int offset = -1;
bc620c5c 3415 enum machine_mode mode = VOIDmode;
ed6e85ae 3416 df_ref use;
30de5b55 3417
3418 if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
3419 {
bf1f8fbc 3420 width = DF_REF_EXTRACT_WIDTH (ref);
3421 offset = DF_REF_EXTRACT_OFFSET (ref);
3422 mode = DF_REF_EXTRACT_MODE (ref);
30de5b55 3423 }
3424
ed6e85ae 3425 use = df_ref_create_structure (DF_REF_CLASS (ref), collection_rec, DF_REF_REG (ref),
30de5b55 3426 DF_REF_LOC (ref), DF_REF_BB (ref),
158b6cc9 3427 DF_REF_INSN_INFO (ref), DF_REF_REG_USE,
30de5b55 3428 DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL,
bf1f8fbc 3429 width, offset, mode);
3072d30e 3430 DF_REF_REGNO (use) = DF_REF_REGNO (ref);
3431 }
3432 }
e011eba9 3433}
3434
3435
3072d30e 3436/* Get call's extra defs and uses. */
e011eba9 3437
3438static void
3072d30e 3439df_get_call_refs (struct df_collection_rec * collection_rec,
3440 basic_block bb,
158b6cc9 3441 struct df_insn_info *insn_info,
b9c74b4d 3442 int flags)
e011eba9 3443{
3072d30e 3444 rtx note;
3445 bitmap_iterator bi;
3446 unsigned int ui;
3447 bool is_sibling_call;
3448 unsigned int i;
f7f05a07 3449 df_ref def;
3072d30e 3450 bitmap defs_generated = BITMAP_ALLOC (&df_bitmap_obstack);
e011eba9 3451
3072d30e 3452 /* Do not generate clobbers for registers that are the result of the
3453 call. This causes ordering problems in the chain building code
3454 depending on which def is seen first. */
f7f05a07 3455 for (i = 0; VEC_iterate (df_ref, collection_rec->def_vec, i, def); ++i)
3456 bitmap_set_bit (defs_generated, DF_REF_REGNO (def));
e011eba9 3457
3072d30e 3458 /* Record the registers used to pass arguments, and explicitly
3459 noted as clobbered. */
158b6cc9 3460 for (note = CALL_INSN_FUNCTION_USAGE (insn_info->insn); note;
3072d30e 3461 note = XEXP (note, 1))
3462 {
3463 if (GET_CODE (XEXP (note, 0)) == USE)
ed6e85ae 3464 df_uses_record (DF_REF_REGULAR, collection_rec, &XEXP (XEXP (note, 0), 0),
b9c74b4d 3465 DF_REF_REG_USE, bb, insn_info, flags, -1, -1,
3466 VOIDmode);
3072d30e 3467 else if (GET_CODE (XEXP (note, 0)) == CLOBBER)
3468 {
5736c998 3469 if (REG_P (XEXP (XEXP (note, 0), 0)))
3470 {
3471 unsigned int regno = REGNO (XEXP (XEXP (note, 0), 0));
3472 if (!bitmap_bit_p (defs_generated, regno))
3473 df_defs_record (collection_rec, XEXP (note, 0), bb,
158b6cc9 3474 insn_info, flags);
5736c998 3475 }
3476 else
ed6e85ae 3477 df_uses_record (DF_REF_REGULAR, collection_rec, &XEXP (note, 0),
b9c74b4d 3478 DF_REF_REG_USE, bb, insn_info, flags, -1, -1,
3479 VOIDmode);
3072d30e 3480 }
3481 }
e011eba9 3482
3072d30e 3483 /* The stack ptr is used (honorarily) by a CALL insn. */
ed6e85ae 3484 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[STACK_POINTER_REGNUM],
158b6cc9 3485 NULL, bb, insn_info, DF_REF_REG_USE,
3486 DF_REF_CALL_STACK_USAGE | flags,
b9c74b4d 3487 -1, -1, VOIDmode);
e011eba9 3488
3072d30e 3489 /* Calls may also reference any of the global registers,
3490 so they are recorded as used. */
3491 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3492 if (global_regs[i])
fbc08f2b 3493 {
ed6e85ae 3494 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
b9c74b4d 3495 NULL, bb, insn_info, DF_REF_REG_USE, flags, -1, -1,
3496 VOIDmode);
ed6e85ae 3497 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[i],
b9c74b4d 3498 NULL, bb, insn_info, DF_REF_REG_DEF, flags, -1, -1,
3499 VOIDmode);
fbc08f2b 3500 }
e011eba9 3501
158b6cc9 3502 is_sibling_call = SIBLING_CALL_P (insn_info->insn);
b888113c 3503 EXECUTE_IF_SET_IN_BITMAP (regs_invalidated_by_call_regset, 0, ui, bi)
3072d30e 3504 {
fbc08f2b 3505 if (!global_regs[ui]
3506 && (!bitmap_bit_p (defs_generated, ui))
3072d30e 3507 && (!is_sibling_call
3508 || !bitmap_bit_p (df->exit_block_uses, ui)
3509 || refers_to_regno_p (ui, ui+1,
abe32cce 3510 crtl->return_rtx, NULL)))
ed6e85ae 3511 df_ref_record (DF_REF_BASE, collection_rec, regno_reg_rtx[ui],
158b6cc9 3512 NULL, bb, insn_info, DF_REF_REG_DEF,
3513 DF_REF_MAY_CLOBBER | flags,
b9c74b4d 3514 -1, -1, VOIDmode);
3072d30e 3515 }
3516
3517 BITMAP_FREE (defs_generated);
3518 return;
3519}
e011eba9 3520
3072d30e 3521/* Collect all refs in the INSN. This function is free of any
3522 side-effect - it will create and return a lists of df_ref's in the
3523 COLLECTION_REC without putting those refs into existing ref chains
3524 and reg chains. */
e011eba9 3525
3072d30e 3526static void
3527df_insn_refs_collect (struct df_collection_rec* collection_rec,
158b6cc9 3528 basic_block bb, struct df_insn_info *insn_info)
3072d30e 3529{
3530 rtx note;
158b6cc9 3531 bool is_cond_exec = (GET_CODE (PATTERN (insn_info->insn)) == COND_EXEC);
e011eba9 3532
3072d30e 3533 /* Clear out the collection record. */
f7f05a07 3534 VEC_truncate (df_ref, collection_rec->def_vec, 0);
3535 VEC_truncate (df_ref, collection_rec->use_vec, 0);
3536 VEC_truncate (df_ref, collection_rec->eq_use_vec, 0);
3537 VEC_truncate (df_mw_hardreg_ptr, collection_rec->mw_vec, 0);
e011eba9 3538
3072d30e 3539 /* Record register defs. */
158b6cc9 3540 df_defs_record (collection_rec, PATTERN (insn_info->insn), bb, insn_info, 0);
3072d30e 3541
158b6cc9 3542 /* Process REG_EQUIV/REG_EQUAL notes. */
3543 for (note = REG_NOTES (insn_info->insn); note;
3072d30e 3544 note = XEXP (note, 1))
3545 {
3546 switch (REG_NOTE_KIND (note))
3547 {
3548 case REG_EQUIV:
3549 case REG_EQUAL:
ed6e85ae 3550 df_uses_record (DF_REF_REGULAR, collection_rec,
3072d30e 3551 &XEXP (note, 0), DF_REF_REG_USE,
b9c74b4d 3552 bb, insn_info, DF_REF_IN_NOTE, -1, -1, VOIDmode);
3072d30e 3553 break;
3554 case REG_NON_LOCAL_GOTO:
3555 /* The frame ptr is used by a non-local goto. */
ed6e85ae 3556 df_ref_record (DF_REF_BASE, collection_rec,
3072d30e 3557 regno_reg_rtx[FRAME_POINTER_REGNUM],
158b6cc9 3558 NULL, bb, insn_info,
b9c74b4d 3559 DF_REF_REG_USE, 0, -1, -1, VOIDmode);
3072d30e 3560#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
ed6e85ae 3561 df_ref_record (DF_REF_BASE, collection_rec,
3072d30e 3562 regno_reg_rtx[HARD_FRAME_POINTER_REGNUM],
158b6cc9 3563 NULL, bb, insn_info,
b9c74b4d 3564 DF_REF_REG_USE, 0, -1, -1, VOIDmode);
3072d30e 3565#endif
3566 break;
3567 default:
3568 break;
3569 }
e011eba9 3570 }
3072d30e 3571
158b6cc9 3572 if (CALL_P (insn_info->insn))
3573 df_get_call_refs (collection_rec, bb, insn_info,
3072d30e 3574 (is_cond_exec) ? DF_REF_CONDITIONAL : 0);
3575
3576 /* Record the register uses. */
ed6e85ae 3577 df_uses_record (DF_REF_REGULAR, collection_rec,
158b6cc9 3578 &PATTERN (insn_info->insn), DF_REF_REG_USE, bb, insn_info, 0,
b9c74b4d 3579 -1, -1, VOIDmode);
3072d30e 3580
3581 /* DF_REF_CONDITIONAL needs corresponding USES. */
3582 if (is_cond_exec)
3583 df_get_conditional_uses (collection_rec);
3584
3585 df_canonize_collection_rec (collection_rec);
e011eba9 3586}
3587
3072d30e 3588/* Recompute the luids for the insns in BB. */
3589
3590void
3591df_recompute_luids (basic_block bb)
e011eba9 3592{
e011eba9 3593 rtx insn;
3594 int luid = 0;
3e6933a8 3595
3072d30e 3596 df_grow_insn_info ();
e011eba9 3597
3598 /* Scan the block an insn at a time from beginning to end. */
3599 FOR_BB_INSNS (bb, insn)
3600 {
158b6cc9 3601 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
3072d30e 3602 /* Inserting labels does not always trigger the incremental
3603 rescanning. */
3604 if (!insn_info)
e011eba9 3605 {
3072d30e 3606 gcc_assert (!INSN_P (insn));
158b6cc9 3607 insn_info = df_insn_create_insn_record (insn);
e011eba9 3608 }
3072d30e 3609
158b6cc9 3610 DF_INSN_INFO_LUID (insn_info) = luid;
3072d30e 3611 if (INSN_P (insn))
3612 luid++;
3613 }
3614}
3615
3616
3072d30e 3617/* Collect all artificial refs at the block level for BB and add them
3618 to COLLECTION_REC. */
3619
3620static void
3621df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb)
3622{
f7f05a07 3623 VEC_truncate (df_ref, collection_rec->def_vec, 0);
3624 VEC_truncate (df_ref, collection_rec->use_vec, 0);
3625 VEC_truncate (df_ref, collection_rec->eq_use_vec, 0);
3626 VEC_truncate (df_mw_hardreg_ptr, collection_rec->mw_vec, 0);
3072d30e 3627
3628 if (bb->index == ENTRY_BLOCK)
3629 {
3630 df_entry_block_defs_collect (collection_rec, df->entry_block_defs);
3631 return;
3632 }
3633 else if (bb->index == EXIT_BLOCK)
3634 {
3635 df_exit_block_uses_collect (collection_rec, df->exit_block_uses);
3636 return;
e011eba9 3637 }
3638
3639#ifdef EH_RETURN_DATA_REGNO
dea7b504 3640 if (bb_has_eh_pred (bb))
e011eba9 3641 {
3642 unsigned int i;
3643 /* Mark the registers that will contain data for the handler. */
fcf2ad9f 3644 for (i = 0; ; ++i)
3645 {
3646 unsigned regno = EH_RETURN_DATA_REGNO (i);
3647 if (regno == INVALID_REGNUM)
3648 break;
ed6e85ae 3649 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
b9c74b4d 3650 bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1,
3651 VOIDmode);
fcf2ad9f 3652 }
e011eba9 3653 }
3654#endif
3655
3072d30e 3656 /* Add the hard_frame_pointer if this block is the target of a
3657 non-local goto. */
3658 if (bb->flags & BB_NON_LOCAL_GOTO_TARGET)
ed6e85ae 3659 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, hard_frame_pointer_rtx, NULL,
b9c74b4d 3660 bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1, VOIDmode);
3072d30e 3661
3662 /* Add the artificial uses. */
3663 if (bb->index >= NUM_FIXED_BLOCKS)
3e6933a8 3664 {
3665 bitmap_iterator bi;
3666 unsigned int regno;
dea7b504 3667 bitmap au = bb_has_eh_pred (bb)
3072d30e 3668 ? df->eh_block_artificial_uses
3669 : df->regular_block_artificial_uses;
3e6933a8 3670
3072d30e 3671 EXECUTE_IF_SET_IN_BITMAP (au, 0, regno, bi)
3e6933a8 3672 {
ed6e85ae 3673 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[regno], NULL,
b9c74b4d 3674 bb, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
3e6933a8 3675 }
e011eba9 3676 }
3072d30e 3677
3678 df_canonize_collection_rec (collection_rec);
e011eba9 3679}
3680
05268a5f 3681
3072d30e 3682/* Record all the refs within the basic block BB_INDEX and scan the instructions if SCAN_INSNS. */
3683
3684void
3685df_bb_refs_record (int bb_index, bool scan_insns)
05268a5f 3686{
3072d30e 3687 basic_block bb = BASIC_BLOCK (bb_index);
3688 rtx insn;
3689 int luid = 0;
3690 struct df_scan_bb_info *bb_info;
3691 struct df_collection_rec collection_rec;
05268a5f 3692
3072d30e 3693 if (!df)
05268a5f 3694 return;
3695
3072d30e 3696 bb_info = df_scan_get_bb_info (bb_index);
05268a5f 3697
3072d30e 3698 /* Need to make sure that there is a record in the basic block info. */
3699 if (!bb_info)
3700 {
3701 bb_info = (struct df_scan_bb_info *) pool_alloc (df_scan->block_pool);
3702 df_scan_set_bb_info (bb_index, bb_info);
3703 bb_info->artificial_defs = NULL;
3704 bb_info->artificial_uses = NULL;
05268a5f 3705 }
3072d30e 3706
f7f05a07 3707 collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
3708 collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
3709 collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
3710 collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
3711
3072d30e 3712 if (scan_insns)
3713 /* Scan the block an insn at a time from beginning to end. */
3714 FOR_BB_INSNS (bb, insn)
3715 {
158b6cc9 3716 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
3072d30e 3717 gcc_assert (!insn_info);
3718
158b6cc9 3719 insn_info = df_insn_create_insn_record (insn);
3072d30e 3720 if (INSN_P (insn))
3721 {
3722 /* Record refs within INSN. */
158b6cc9 3723 DF_INSN_INFO_LUID (insn_info) = luid++;
3724 df_insn_refs_collect (&collection_rec, bb, DF_INSN_INFO_GET (insn));
3072d30e 3725 df_refs_add_to_chains (&collection_rec, bb, insn);
3726 }
158b6cc9 3727 DF_INSN_INFO_LUID (insn_info) = luid;
3072d30e 3728 }
3729
3730 /* Other block level artificial refs */
3731 df_bb_refs_collect (&collection_rec, bb);
3732 df_refs_add_to_chains (&collection_rec, bb, NULL);
3733
f7f05a07 3734 VEC_free (df_ref, stack, collection_rec.def_vec);
3735 VEC_free (df_ref, stack, collection_rec.use_vec);
3736 VEC_free (df_ref, stack, collection_rec.eq_use_vec);
3737 VEC_free (df_mw_hardreg_ptr, stack, collection_rec.mw_vec);
3738
3072d30e 3739 /* Now that the block has been processed, set the block as dirty so
84da8954 3740 LR and LIVE will get it processed. */
3072d30e 3741 df_set_bb_dirty (bb);
05268a5f 3742}
e011eba9 3743
3072d30e 3744
3745/* Get the artificial use set for a regular (i.e. non-exit/non-entry)
3746 block. */
e011eba9 3747
3748static void
3072d30e 3749df_get_regular_block_artificial_uses (bitmap regular_block_artificial_uses)
e011eba9 3750{
f7039b33 3751#ifdef EH_USES
3752 unsigned int i;
3753#endif
3754
3072d30e 3755 bitmap_clear (regular_block_artificial_uses);
e011eba9 3756
3072d30e 3757 if (reload_completed)
e011eba9 3758 {
3072d30e 3759 if (frame_pointer_needed)
3760 bitmap_set_bit (regular_block_artificial_uses, HARD_FRAME_POINTER_REGNUM);
3761 }
3762 else
3763 /* Before reload, there are a few registers that must be forced
3764 live everywhere -- which might not already be the case for
3765 blocks within infinite loops. */
3766 {
3767 /* Any reference to any pseudo before reload is a potential
3768 reference of the frame pointer. */
3769 bitmap_set_bit (regular_block_artificial_uses, FRAME_POINTER_REGNUM);
3770
3771#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3772 bitmap_set_bit (regular_block_artificial_uses, HARD_FRAME_POINTER_REGNUM);
3773#endif
3774
3775#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3776 /* Pseudos with argument area equivalences may require
3777 reloading via the argument pointer. */
3778 if (fixed_regs[ARG_POINTER_REGNUM])
3779 bitmap_set_bit (regular_block_artificial_uses, ARG_POINTER_REGNUM);
3780#endif
3781
3782 /* Any constant, or pseudo with constant equivalences, may
3783 require reloading from memory using the pic register. */
3784 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
3785 && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
3786 bitmap_set_bit (regular_block_artificial_uses, PIC_OFFSET_TABLE_REGNUM);
e011eba9 3787 }
3072d30e 3788 /* The all-important stack pointer must always be live. */
3789 bitmap_set_bit (regular_block_artificial_uses, STACK_POINTER_REGNUM);
f7039b33 3790
3791#ifdef EH_USES
3792 /* EH_USES registers are used:
3793 1) at all insns that might throw (calls or with -fnon-call-exceptions
3794 trapping insns)
3795 2) in all EH edges
3796 3) to support backtraces and/or debugging, anywhere between their
3797 initialization and where they the saved registers are restored
3798 from them, including the cases where we don't reach the epilogue
3799 (noreturn call or infinite loop). */
3800 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3801 if (EH_USES (i))
3802 bitmap_set_bit (regular_block_artificial_uses, i);
3803#endif
3072d30e 3804}
3805
e011eba9 3806
3072d30e 3807/* Get the artificial use set for an eh block. */
fcf2ad9f 3808
3072d30e 3809static void
3810df_get_eh_block_artificial_uses (bitmap eh_block_artificial_uses)
3811{
3812 bitmap_clear (eh_block_artificial_uses);
05268a5f 3813
6dfdc153 3814 /* The following code (down thru the arg_pointer setting APPEARS
3072d30e 3815 to be necessary because there is nothing that actually
3816 describes what the exception handling code may actually need
3817 to keep alive. */
3818 if (reload_completed)
3819 {
3820 if (frame_pointer_needed)
3821 {
3822 bitmap_set_bit (eh_block_artificial_uses, FRAME_POINTER_REGNUM);
3823#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3824 bitmap_set_bit (eh_block_artificial_uses, HARD_FRAME_POINTER_REGNUM);
3825#endif
3826 }
3827#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3828 if (fixed_regs[ARG_POINTER_REGNUM])
3829 bitmap_set_bit (eh_block_artificial_uses, ARG_POINTER_REGNUM);
3830#endif
3831 }
e011eba9 3832}
3833
3834
3072d30e 3835\f
e011eba9 3836/*----------------------------------------------------------------------------
3837 Specialized hard register scanning functions.
3838----------------------------------------------------------------------------*/
3839
3072d30e 3840
e011eba9 3841/* Mark a register in SET. Hard registers in large modes get all
3842 of their component registers set as well. */
3843
3844static void
3845df_mark_reg (rtx reg, void *vset)
3846{
3847 bitmap set = (bitmap) vset;
3848 int regno = REGNO (reg);
3849
3850 gcc_assert (GET_MODE (reg) != BLKmode);
3851
3852 bitmap_set_bit (set, regno);
3853 if (regno < FIRST_PSEUDO_REGISTER)
3854 {
3855 int n = hard_regno_nregs[regno][GET_MODE (reg)];
3856 while (--n > 0)
3857 bitmap_set_bit (set, regno + n);
3858 }
3859}
3860
fcf2ad9f 3861
3072d30e 3862/* Set the bit for regs that are considered being defined at the entry. */
fcf2ad9f 3863
3864static void
3072d30e 3865df_get_entry_block_def_set (bitmap entry_block_defs)
fcf2ad9f 3866{
fcf2ad9f 3867 rtx r;
3072d30e 3868 int i;
fcf2ad9f 3869
3072d30e 3870 bitmap_clear (entry_block_defs);
fcf2ad9f 3871
3872 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3873 {
3874 if (FUNCTION_ARG_REGNO_P (i))
3875#ifdef INCOMING_REGNO
3072d30e 3876 bitmap_set_bit (entry_block_defs, INCOMING_REGNO (i));
fcf2ad9f 3877#else
3072d30e 3878 bitmap_set_bit (entry_block_defs, i);
fcf2ad9f 3879#endif
3880 }
3881
df4fadd5 3882 /* The always important stack pointer. */
3883 bitmap_set_bit (entry_block_defs, STACK_POINTER_REGNUM);
3884
fcf2ad9f 3885 /* Once the prologue has been generated, all of these registers
3886 should just show up in the first regular block. */
3887 if (HAVE_prologue && epilogue_completed)
3888 {
3889 /* Defs for the callee saved registers are inserted so that the
3890 pushes have some defining location. */
3891 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3072d30e 3892 if ((call_used_regs[i] == 0) && (df_regs_ever_live_p (i)))
3893 bitmap_set_bit (entry_block_defs, i);
fcf2ad9f 3894 }
fcf2ad9f 3895
652ff291 3896 r = targetm.calls.struct_value_rtx (current_function_decl, true);
3897 if (r && REG_P (r))
3898 bitmap_set_bit (entry_block_defs, REGNO (r));
3899
82c7907c 3900 /* If the function has an incoming STATIC_CHAIN, it has to show up
3901 in the entry def set. */
3902 r = targetm.calls.static_chain (current_function_decl, true);
3903 if (r && REG_P (r))
3904 bitmap_set_bit (entry_block_defs, REGNO (r));
3905
3e6933a8 3906 if ((!reload_completed) || frame_pointer_needed)
fcf2ad9f 3907 {
3908 /* Any reference to any pseudo before reload is a potential
3909 reference of the frame pointer. */
3072d30e 3910 bitmap_set_bit (entry_block_defs, FRAME_POINTER_REGNUM);
3e6933a8 3911#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3912 /* If they are different, also mark the hard frame pointer as live. */
3913 if (!LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
3072d30e 3914 bitmap_set_bit (entry_block_defs, HARD_FRAME_POINTER_REGNUM);
3e6933a8 3915#endif
3916 }
fcf2ad9f 3917
3e6933a8 3918 /* These registers are live everywhere. */
3919 if (!reload_completed)
3920 {
fcf2ad9f 3921#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3922 /* Pseudos with argument area equivalences may require
3923 reloading via the argument pointer. */
3924 if (fixed_regs[ARG_POINTER_REGNUM])
3072d30e 3925 bitmap_set_bit (entry_block_defs, ARG_POINTER_REGNUM);
fcf2ad9f 3926#endif
3927
3928#ifdef PIC_OFFSET_TABLE_REGNUM
3929 /* Any constant, or pseudo with constant equivalences, may
3930 require reloading from memory using the pic register. */
3931 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
3932 && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
3072d30e 3933 bitmap_set_bit (entry_block_defs, PIC_OFFSET_TABLE_REGNUM);
3934#endif
3935 }
3936
3937#ifdef INCOMING_RETURN_ADDR_RTX
3938 if (REG_P (INCOMING_RETURN_ADDR_RTX))
3939 bitmap_set_bit (entry_block_defs, REGNO (INCOMING_RETURN_ADDR_RTX));
3940#endif
3941
3942 targetm.live_on_entry (entry_block_defs);
3072d30e 3943}
3944
3945
3946/* Return the (conservative) set of hard registers that are defined on
3947 entry to the function.
bef304b8 3948 It uses df->entry_block_defs to determine which register
3072d30e 3949 reference to include. */
3950
3951static void
3952df_entry_block_defs_collect (struct df_collection_rec *collection_rec,
3953 bitmap entry_block_defs)
3954{
3955 unsigned int i;
3956 bitmap_iterator bi;
3957
3958 EXECUTE_IF_SET_IN_BITMAP (entry_block_defs, 0, i, bi)
3959 {
ed6e85ae 3960 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
b9c74b4d 3961 ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0, -1, -1,
3962 VOIDmode);
3072d30e 3963 }
3964
3965 df_canonize_collection_rec (collection_rec);
3966}
3967
3968
3969/* Record the (conservative) set of hard registers that are defined on
3970 entry to the function. */
3971
3972static void
3973df_record_entry_block_defs (bitmap entry_block_defs)
3974{
3975 struct df_collection_rec collection_rec;
3976 memset (&collection_rec, 0, sizeof (struct df_collection_rec));
f7f05a07 3977 collection_rec.def_vec = VEC_alloc (df_ref, stack, FIRST_PSEUDO_REGISTER);
3072d30e 3978 df_entry_block_defs_collect (&collection_rec, entry_block_defs);
3979
3980 /* Process bb_refs chain */
3981 df_refs_add_to_chains (&collection_rec, BASIC_BLOCK (ENTRY_BLOCK), NULL);
f7f05a07 3982 VEC_free (df_ref, stack, collection_rec.def_vec);
3072d30e 3983}
3984
3985
becfaa62 3986/* Update the defs in the entry block. */
3072d30e 3987
3988void
3989df_update_entry_block_defs (void)
3990{
3991 bitmap refs = BITMAP_ALLOC (&df_bitmap_obstack);
3992 bool changed = false;
fcf2ad9f 3993
3072d30e 3994 df_get_entry_block_def_set (refs);
3995 if (df->entry_block_defs)
3996 {
3997 if (!bitmap_equal_p (df->entry_block_defs, refs))
3998 {
3999 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (ENTRY_BLOCK);
4000 df_ref_chain_delete_du_chain (bb_info->artificial_defs);
4001 df_ref_chain_delete (bb_info->artificial_defs);
4002 bb_info->artificial_defs = NULL;
4003 changed = true;
4004 }
4005 }
4006 else
4007 {
4008 struct df_scan_problem_data *problem_data
4009 = (struct df_scan_problem_data *) df_scan->problem_data;
4010 df->entry_block_defs = BITMAP_ALLOC (&problem_data->reg_bitmaps);
4011 changed = true;
4012 }
fcf2ad9f 4013
3072d30e 4014 if (changed)
fcf2ad9f 4015 {
3072d30e 4016 df_record_entry_block_defs (refs);
4017 bitmap_copy (df->entry_block_defs, refs);
4018 df_set_bb_dirty (BASIC_BLOCK (ENTRY_BLOCK));
fcf2ad9f 4019 }
3072d30e 4020 BITMAP_FREE (refs);
fcf2ad9f 4021}
4022
4023
3072d30e 4024/* Set the bit for regs that are considered being used at the exit. */
e011eba9 4025
4026static void
3072d30e 4027df_get_exit_block_use_set (bitmap exit_block_uses)
e011eba9 4028{
4029 unsigned int i;
e011eba9 4030
3072d30e 4031 bitmap_clear (exit_block_uses);
bff9eb26 4032
4033 /* Stack pointer is always live at the exit. */
4034 bitmap_set_bit (exit_block_uses, STACK_POINTER_REGNUM);
e011eba9 4035
4036 /* Mark the frame pointer if needed at the end of the function.
4037 If we end up eliminating it, it will be removed from the live
4038 list of each basic block by reload. */
4039
3e6933a8 4040 if ((!reload_completed) || frame_pointer_needed)
e011eba9 4041 {
3072d30e 4042 bitmap_set_bit (exit_block_uses, FRAME_POINTER_REGNUM);
e011eba9 4043#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
4044 /* If they are different, also mark the hard frame pointer as live. */
3e6933a8 4045 if (!LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
3072d30e 4046 bitmap_set_bit (exit_block_uses, HARD_FRAME_POINTER_REGNUM);
e011eba9 4047#endif
4048 }
4049
4050#ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
4051 /* Many architectures have a GP register even without flag_pic.
4052 Assume the pic register is not in use, or will be handled by
4053 other means, if it is not fixed. */
4054 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
4055 && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
3072d30e 4056 bitmap_set_bit (exit_block_uses, PIC_OFFSET_TABLE_REGNUM);
e011eba9 4057#endif
4058
4059 /* Mark all global registers, and all registers used by the
4060 epilogue as being live at the end of the function since they
4061 may be referenced by our caller. */
4062 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4063 if (global_regs[i] || EPILOGUE_USES (i))
3072d30e 4064 bitmap_set_bit (exit_block_uses, i);
e011eba9 4065
4066 if (HAVE_epilogue && epilogue_completed)
4067 {
4068 /* Mark all call-saved registers that we actually used. */
4069 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3072d30e 4070 if (df_regs_ever_live_p (i) && !LOCAL_REGNO (i)
3e6933a8 4071 && !TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
3072d30e 4072 bitmap_set_bit (exit_block_uses, i);
e011eba9 4073 }
4074
4075#ifdef EH_RETURN_DATA_REGNO
4076 /* Mark the registers that will contain data for the handler. */
18d50ae6 4077 if (reload_completed && crtl->calls_eh_return)
e011eba9 4078 for (i = 0; ; ++i)
4079 {
4080 unsigned regno = EH_RETURN_DATA_REGNO (i);
4081 if (regno == INVALID_REGNUM)
4082 break;
3072d30e 4083 bitmap_set_bit (exit_block_uses, regno);
e011eba9 4084 }
4085#endif
4086
4087#ifdef EH_RETURN_STACKADJ_RTX
3e6933a8 4088 if ((!HAVE_epilogue || ! epilogue_completed)
18d50ae6 4089 && crtl->calls_eh_return)
e011eba9 4090 {
4091 rtx tmp = EH_RETURN_STACKADJ_RTX;
4092 if (tmp && REG_P (tmp))
3072d30e 4093 df_mark_reg (tmp, exit_block_uses);
e011eba9 4094 }
4095#endif
4096
4097#ifdef EH_RETURN_HANDLER_RTX
3e6933a8 4098 if ((!HAVE_epilogue || ! epilogue_completed)
18d50ae6 4099 && crtl->calls_eh_return)
e011eba9 4100 {
4101 rtx tmp = EH_RETURN_HANDLER_RTX;
4102 if (tmp && REG_P (tmp))
3072d30e 4103 df_mark_reg (tmp, exit_block_uses);
e011eba9 4104 }
4105#endif
3072d30e 4106
e011eba9 4107 /* Mark function return value. */
3072d30e 4108 diddle_return_value (df_mark_reg, (void*) exit_block_uses);
4109}
4110
4111
4112/* Return the refs of hard registers that are used in the exit block.
4113 It uses df->exit_block_uses to determine register to include. */
4114
4115static void
4116df_exit_block_uses_collect (struct df_collection_rec *collection_rec, bitmap exit_block_uses)
4117{
4118 unsigned int i;
4119 bitmap_iterator bi;
4120
4121 EXECUTE_IF_SET_IN_BITMAP (exit_block_uses, 0, i, bi)
ed6e85ae 4122 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[i], NULL,
b9c74b4d 4123 EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
e011eba9 4124
3072d30e 4125#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4126 /* It is deliberate that this is not put in the exit block uses but
4127 I do not know why. */
4128 if (reload_completed
4129 && !bitmap_bit_p (exit_block_uses, ARG_POINTER_REGNUM)
dea7b504 4130 && bb_has_eh_pred (EXIT_BLOCK_PTR)
3072d30e 4131 && fixed_regs[ARG_POINTER_REGNUM])
ed6e85ae 4132 df_ref_record (DF_REF_ARTIFICIAL, collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL,
b9c74b4d 4133 EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1, VOIDmode);
3072d30e 4134#endif
4135
4136 df_canonize_collection_rec (collection_rec);
4137}
4138
4139
4140/* Record the set of hard registers that are used in the exit block.
4141 It uses df->exit_block_uses to determine which bit to include. */
4142
4143static void
4144df_record_exit_block_uses (bitmap exit_block_uses)
4145{
4146 struct df_collection_rec collection_rec;
4147 memset (&collection_rec, 0, sizeof (struct df_collection_rec));
f7f05a07 4148 collection_rec.use_vec = VEC_alloc (df_ref, stack, FIRST_PSEUDO_REGISTER);
3072d30e 4149
4150 df_exit_block_uses_collect (&collection_rec, exit_block_uses);
4151
4152 /* Process bb_refs chain */
4153 df_refs_add_to_chains (&collection_rec, BASIC_BLOCK (EXIT_BLOCK), NULL);
f7f05a07 4154 VEC_free (df_ref, stack, collection_rec.use_vec);
3072d30e 4155}
4156
4157
4158/* Update the uses in the exit block. */
4159
4160void
4161df_update_exit_block_uses (void)
4162{
4163 bitmap refs = BITMAP_ALLOC (&df_bitmap_obstack);
4164 bool changed = false;
4165
4166 df_get_exit_block_use_set (refs);
4167 if (df->exit_block_uses)
4168 {
4169 if (!bitmap_equal_p (df->exit_block_uses, refs))
4170 {
4171 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (EXIT_BLOCK);
4172 df_ref_chain_delete_du_chain (bb_info->artificial_uses);
4173 df_ref_chain_delete (bb_info->artificial_uses);
4174 bb_info->artificial_uses = NULL;
4175 changed = true;
4176 }
4177 }
4178 else
4179 {
4180 struct df_scan_problem_data *problem_data
4181 = (struct df_scan_problem_data *) df_scan->problem_data;
4182 df->exit_block_uses = BITMAP_ALLOC (&problem_data->reg_bitmaps);
4183 changed = true;
4184 }
4185
4186 if (changed)
4187 {
4188 df_record_exit_block_uses (refs);
4189 bitmap_copy (df->exit_block_uses, refs);
4190 df_set_bb_dirty (BASIC_BLOCK (EXIT_BLOCK));
4191 }
4192 BITMAP_FREE (refs);
e011eba9 4193}
4194
4195static bool initialized = false;
4196
3072d30e 4197
e011eba9 4198/* Initialize some platform specific structures. */
4199
4200void
4201df_hard_reg_init (void)
4202{
bebf8106 4203#ifdef ELIMINABLE_REGS
f9a42947 4204 int i;
e011eba9 4205 static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;
4206#endif
e011eba9 4207 if (initialized)
4208 return;
4209
e011eba9 4210 /* Record which registers will be eliminated. We use this in
4211 mark_used_regs. */
4212 CLEAR_HARD_REG_SET (elim_reg_set);
4213
4214#ifdef ELIMINABLE_REGS
4215 for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++)
4216 SET_HARD_REG_BIT (elim_reg_set, eliminables[i].from);
4217#else
4218 SET_HARD_REG_BIT (elim_reg_set, FRAME_POINTER_REGNUM);
4219#endif
4220
e011eba9 4221 initialized = true;
4222}
3072d30e 4223
4224
4225/* Recompute the parts of scanning that are based on regs_ever_live
4226 because something changed in that array. */
4227
4228void
4229df_update_entry_exit_and_calls (void)
4230{
4231 basic_block bb;
4232
4233 df_update_entry_block_defs ();
4234 df_update_exit_block_uses ();
4235
4236 /* The call insns need to be rescanned because there may be changes
4237 in the set of registers clobbered across the call. */
4238 FOR_EACH_BB (bb)
4239 {
4240 rtx insn;
4241 FOR_BB_INSNS (bb, insn)
4242 {
4243 if (INSN_P (insn) && CALL_P (insn))
4244 df_insn_rescan (insn);
4245 }
4246 }
4247}
4248
4249
4250/* Return true if hard REG is actually used in the some instruction.
4251 There are a fair number of conditions that affect the setting of
4252 this array. See the comment in df.h for df->hard_regs_live_count
4253 for the conditions that this array is set. */
4254
4255bool
4256df_hard_reg_used_p (unsigned int reg)
4257{
4258 gcc_assert (df);
4259 return df->hard_regs_live_count[reg] != 0;
4260}
4261
4262
4263/* A count of the number of times REG is actually used in the some
4264 instruction. There are a fair number of conditions that affect the
4265 setting of this array. See the comment in df.h for
4266 df->hard_regs_live_count for the conditions that this array is
4267 set. */
4268
4269
4270unsigned int
4271df_hard_reg_used_count (unsigned int reg)
4272{
4273 gcc_assert (df);
4274 return df->hard_regs_live_count[reg];
4275}
4276
4277
4278/* Get the value of regs_ever_live[REGNO]. */
4279
4280bool
4281df_regs_ever_live_p (unsigned int regno)
4282{
4283 return regs_ever_live[regno];
4284}
4285
4286
4287/* Set regs_ever_live[REGNO] to VALUE. If this cause regs_ever_live
4288 to change, schedule that change for the next update. */
4289
4290void
4291df_set_regs_ever_live (unsigned int regno, bool value)
4292{
4293 if (regs_ever_live[regno] == value)
4294 return;
4295
4296 regs_ever_live[regno] = value;
4297 if (df)
4298 df->redo_entry_and_exit = true;
4299}
4300
4301
4302/* Compute "regs_ever_live" information from the underlying df
4303 information. Set the vector to all false if RESET. */
4304
4305void
4306df_compute_regs_ever_live (bool reset)
4307{
4308 unsigned int i;
4309 bool changed = df->redo_entry_and_exit;
4310
4311 if (reset)
4312 memset (regs_ever_live, 0, sizeof (regs_ever_live));
4313
4314 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4315 if ((!regs_ever_live[i]) && df_hard_reg_used_p (i))
4316 {
4317 regs_ever_live[i] = true;
4318 changed = true;
4319 }
4320 if (changed)
4321 df_update_entry_exit_and_calls ();
4322 df->redo_entry_and_exit = false;
4323}
4324
4325\f
4326/*----------------------------------------------------------------------------
4327 Dataflow ref information verification functions.
4328
4329 df_reg_chain_mark (refs, regno, is_def, is_eq_use)
4330 df_reg_chain_verify_unmarked (refs)
f7f05a07 4331 df_refs_verify (VEC(stack,df_ref)*, ref*, bool)
3072d30e 4332 df_mws_verify (mw*, mw*, bool)
4333 df_insn_refs_verify (collection_rec, bb, insn, bool)
4334 df_bb_refs_verify (bb, refs, bool)
4335 df_bb_verify (bb)
4336 df_exit_block_bitmap_verify (bool)
4337 df_entry_block_bitmap_verify (bool)
4338 df_scan_verify ()
4339----------------------------------------------------------------------------*/
4340
4341
4342/* Mark all refs in the reg chain. Verify that all of the registers
4343are in the correct chain. */
4344
4345static unsigned int
ed6e85ae 4346df_reg_chain_mark (df_ref refs, unsigned int regno,
3072d30e 4347 bool is_def, bool is_eq_use)
4348{
4349 unsigned int count = 0;
ed6e85ae 4350 df_ref ref;
3072d30e 4351 for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
4352 {
4353 gcc_assert (!DF_REF_IS_REG_MARKED (ref));
4354
4355 /* If there are no def-use or use-def chains, make sure that all
4356 of the chains are clear. */
4357 if (!df_chain)
4358 gcc_assert (!DF_REF_CHAIN (ref));
4359
4360 /* Check to make sure the ref is in the correct chain. */
4361 gcc_assert (DF_REF_REGNO (ref) == regno);
4362 if (is_def)
ed6e85ae 4363 gcc_assert (DF_REF_REG_DEF_P (ref));
3072d30e 4364 else
ed6e85ae 4365 gcc_assert (!DF_REF_REG_DEF_P (ref));
3072d30e 4366
4367 if (is_eq_use)
4368 gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE));
4369 else
4370 gcc_assert ((DF_REF_FLAGS (ref) & DF_REF_IN_NOTE) == 0);
4371
ed6e85ae 4372 if (DF_REF_NEXT_REG (ref))
4373 gcc_assert (DF_REF_PREV_REG (DF_REF_NEXT_REG (ref)) == ref);
3072d30e 4374 count++;
4375 DF_REF_REG_MARK (ref);
4376 }
4377 return count;
4378}
4379
4380
4381/* Verify that all of the registers in the chain are unmarked. */
4382
4383static void
ed6e85ae 4384df_reg_chain_verify_unmarked (df_ref refs)
3072d30e 4385{
ed6e85ae 4386 df_ref ref;
3072d30e 4387 for (ref = refs; ref; ref = DF_REF_NEXT_REG (ref))
4388 gcc_assert (!DF_REF_IS_REG_MARKED (ref));
4389}
4390
4391
4392/* Verify that NEW_REC and OLD_REC have exactly the same members. */
4393
4394static bool
f7f05a07 4395df_refs_verify (VEC(df_ref,stack) *new_rec, df_ref *old_rec,
3072d30e 4396 bool abort_if_fail)
4397{
f7f05a07 4398 unsigned int ix;
4399 df_ref new_ref;
4400
4401 for (ix = 0; VEC_iterate (df_ref, new_rec, ix, new_ref); ++ix)
3072d30e 4402 {
f7f05a07 4403 if (*old_rec == NULL || !df_ref_equal_p (new_ref, *old_rec))
3072d30e 4404 {
4405 if (abort_if_fail)
4406 gcc_assert (0);
4407 else
4408 return false;
4409 }
4410
4411 /* Abort if fail is called from the function level verifier. If
4412 that is the context, mark this reg as being seem. */
4413 if (abort_if_fail)
4414 {
4415 gcc_assert (DF_REF_IS_REG_MARKED (*old_rec));
4416 DF_REF_REG_UNMARK (*old_rec);
4417 }
4418
3072d30e 4419 old_rec++;
4420 }
4421
4422 if (abort_if_fail)
f7f05a07 4423 gcc_assert (*old_rec == NULL);
3072d30e 4424 else
f7f05a07 4425 return *old_rec == NULL;
3072d30e 4426 return false;
4427}
4428
4429
4430/* Verify that NEW_REC and OLD_REC have exactly the same members. */
4431
4432static bool
f7f05a07 4433df_mws_verify (VEC(df_mw_hardreg_ptr,stack) *new_rec,
4434 struct df_mw_hardreg **old_rec,
3072d30e 4435 bool abort_if_fail)
4436{
f7f05a07 4437 unsigned int ix;
4438 struct df_mw_hardreg *new_reg;
4439
4440 for (ix = 0; VEC_iterate (df_mw_hardreg_ptr, new_rec, ix, new_reg); ++ix)
3072d30e 4441 {
f7f05a07 4442 if (*old_rec == NULL || !df_mw_equal_p (new_reg, *old_rec))
3072d30e 4443 {
4444 if (abort_if_fail)
4445 gcc_assert (0);
4446 else
4447 return false;
4448 }
3072d30e 4449 old_rec++;
4450 }
4451
4452 if (abort_if_fail)
f7f05a07 4453 gcc_assert (*old_rec == NULL);
3072d30e 4454 else
f7f05a07 4455 return *old_rec == NULL;
3072d30e 4456 return false;
4457}
4458
4459
4460/* Return true if the existing insn refs information is complete and
4461 correct. Otherwise (i.e. if there's any missing or extra refs),
4462 return the correct df_ref chain in REFS_RETURN.
4463
4464 If ABORT_IF_FAIL, leave the refs that are verified (already in the
4465 ref chain) as DF_REF_MARKED(). If it's false, then it's a per-insn
4466 verification mode instead of the whole function, so unmark
4467 everything.
4468
4469 If ABORT_IF_FAIL is set, this function never returns false. */
4470
4471static bool
4472df_insn_refs_verify (struct df_collection_rec *collection_rec,
4473 basic_block bb,
4474 rtx insn,
4475 bool abort_if_fail)
4476{
4477 bool ret1, ret2, ret3, ret4;
4478 unsigned int uid = INSN_UID (insn);
158b6cc9 4479 struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
3072d30e 4480
158b6cc9 4481 df_insn_refs_collect (collection_rec, bb, insn_info);
3072d30e 4482
4483 if (!DF_INSN_UID_DEFS (uid))
4484 {
4485 /* The insn_rec was created but it was never filled out. */
4486 if (abort_if_fail)
4487 gcc_assert (0);
4488 else
4489 return false;
4490 }
4491
4492 /* Unfortunately we cannot opt out early if one of these is not
4493 right because the marks will not get cleared. */
4494 ret1 = df_refs_verify (collection_rec->def_vec, DF_INSN_UID_DEFS (uid),
4495 abort_if_fail);
4496 ret2 = df_refs_verify (collection_rec->use_vec, DF_INSN_UID_USES (uid),
4497 abort_if_fail);
4498 ret3 = df_refs_verify (collection_rec->eq_use_vec, DF_INSN_UID_EQ_USES (uid),
4499 abort_if_fail);
4500 ret4 = df_mws_verify (collection_rec->mw_vec, DF_INSN_UID_MWS (uid),
4501 abort_if_fail);
4502 return (ret1 && ret2 && ret3 && ret4);
4503}
4504
4505
4506/* Return true if all refs in the basic block are correct and complete.
4507 Due to df_ref_chain_verify, it will cause all refs
4508 that are verified to have DF_REF_MARK bit set. */
4509
4510static bool
4511df_bb_verify (basic_block bb)
4512{
4513 rtx insn;
4514 struct df_scan_bb_info *bb_info = df_scan_get_bb_info (bb->index);
4515 struct df_collection_rec collection_rec;
4516
4517 memset (&collection_rec, 0, sizeof (struct df_collection_rec));
f7f05a07 4518 collection_rec.def_vec = VEC_alloc (df_ref, stack, 128);
4519 collection_rec.use_vec = VEC_alloc (df_ref, stack, 32);
4520 collection_rec.eq_use_vec = VEC_alloc (df_ref, stack, 32);
4521 collection_rec.mw_vec = VEC_alloc (df_mw_hardreg_ptr, stack, 32);
3072d30e 4522
4523 gcc_assert (bb_info);
4524
ed6e85ae 4525 /* Scan the block, one insn at a time, from beginning to end. */
3072d30e 4526 FOR_BB_INSNS_REVERSE (bb, insn)
4527 {
4528 if (!INSN_P (insn))
4529 continue;
4530 df_insn_refs_verify (&collection_rec, bb, insn, true);
4531 df_free_collection_rec (&collection_rec);
4532 }
4533
4534 /* Do the artificial defs and uses. */
4535 df_bb_refs_collect (&collection_rec, bb);
4536 df_refs_verify (collection_rec.def_vec, df_get_artificial_defs (bb->index), true);
4537 df_refs_verify (collection_rec.use_vec, df_get_artificial_uses (bb->index), true);
4538 df_free_collection_rec (&collection_rec);
4539
4540 return true;
4541}
4542
4543
4544/* Returns true if the entry block has correct and complete df_ref set.
4545 If not it either aborts if ABORT_IF_FAIL is true or returns false. */
4546
4547static bool
4548df_entry_block_bitmap_verify (bool abort_if_fail)
4549{
4550 bitmap entry_block_defs = BITMAP_ALLOC (&df_bitmap_obstack);
4551 bool is_eq;
4552
4553 df_get_entry_block_def_set (entry_block_defs);
4554
4555 is_eq = bitmap_equal_p (entry_block_defs, df->entry_block_defs);
4556
4557 if (!is_eq && abort_if_fail)
4558 {
4559 print_current_pass (stderr);
4560 fprintf (stderr, "entry_block_defs = ");
4561 df_print_regset (stderr, entry_block_defs);
4562 fprintf (stderr, "df->entry_block_defs = ");
4563 df_print_regset (stderr, df->entry_block_defs);
4564 gcc_assert (0);
4565 }
4566
4567 BITMAP_FREE (entry_block_defs);
4568
4569 return is_eq;
4570}
4571
4572
4573/* Returns true if the exit block has correct and complete df_ref set.
4574 If not it either aborts if ABORT_IF_FAIL is true or returns false. */
4575
4576static bool
4577df_exit_block_bitmap_verify (bool abort_if_fail)
4578{
4579 bitmap exit_block_uses = BITMAP_ALLOC (&df_bitmap_obstack);
4580 bool is_eq;
4581
4582 df_get_exit_block_use_set (exit_block_uses);
4583
4584 is_eq = bitmap_equal_p (exit_block_uses, df->exit_block_uses);
4585
4586 if (!is_eq && abort_if_fail)
4587 {
4588 print_current_pass (stderr);
4589 fprintf (stderr, "exit_block_uses = ");
4590 df_print_regset (stderr, exit_block_uses);
4591 fprintf (stderr, "df->exit_block_uses = ");
4592 df_print_regset (stderr, df->exit_block_uses);
4593 gcc_assert (0);
4594 }
4595
4596 BITMAP_FREE (exit_block_uses);
4597
4598 return is_eq;
4599}
4600
4601
bf1f8fbc 4602/* Return true if df_ref information for all insns in all blocks are
4603 correct and complete. */
3072d30e 4604
4605void
4606df_scan_verify (void)
4607{
4608 unsigned int i;
4609 basic_block bb;
4610 bitmap regular_block_artificial_uses;
4611 bitmap eh_block_artificial_uses;
4612
4613 if (!df)
4614 return;
4615
3072d30e 4616 /* Verification is a 4 step process. */
4617
4618 /* (1) All of the refs are marked by going thru the reg chains. */
4619 for (i = 0; i < DF_REG_SIZE (df); i++)
4620 {
4621 gcc_assert (df_reg_chain_mark (DF_REG_DEF_CHAIN (i), i, true, false)
4622 == DF_REG_DEF_COUNT(i));
4623 gcc_assert (df_reg_chain_mark (DF_REG_USE_CHAIN (i), i, false, false)
4624 == DF_REG_USE_COUNT(i));
4625 gcc_assert (df_reg_chain_mark (DF_REG_EQ_USE_CHAIN (i), i, false, true)
4626 == DF_REG_EQ_USE_COUNT(i));
4627 }
4628
4629 /* (2) There are various bitmaps whose value may change over the
4630 course of the compilation. This step recomputes them to make
4631 sure that they have not slipped out of date. */
4632 regular_block_artificial_uses = BITMAP_ALLOC (&df_bitmap_obstack);
4633 eh_block_artificial_uses = BITMAP_ALLOC (&df_bitmap_obstack);
4634
4635 df_get_regular_block_artificial_uses (regular_block_artificial_uses);
4636 df_get_eh_block_artificial_uses (eh_block_artificial_uses);
4637
4638 bitmap_ior_into (eh_block_artificial_uses,
4639 regular_block_artificial_uses);
4640
4641 /* Check artificial_uses bitmaps didn't change. */
4642 gcc_assert (bitmap_equal_p (regular_block_artificial_uses,
4643 df->regular_block_artificial_uses));
4644 gcc_assert (bitmap_equal_p (eh_block_artificial_uses,
4645 df->eh_block_artificial_uses));
4646
4647 BITMAP_FREE (regular_block_artificial_uses);
4648 BITMAP_FREE (eh_block_artificial_uses);
4649
4650 /* Verify entry block and exit block. These only verify the bitmaps,
4651 the refs are verified in df_bb_verify. */
4652 df_entry_block_bitmap_verify (true);
4653 df_exit_block_bitmap_verify (true);
4654
4655 /* (3) All of the insns in all of the blocks are traversed and the
4656 marks are cleared both in the artificial refs attached to the
4657 blocks and the real refs inside the insns. It is a failure to
4658 clear a mark that has not been set as this means that the ref in
4659 the block or insn was not in the reg chain. */
4660
4661 FOR_ALL_BB (bb)
4662 df_bb_verify (bb);
4663
4664 /* (4) See if all reg chains are traversed a second time. This time
4665 a check is made that the marks are clear. A set mark would be a
4666 from a reg that is not in any insn or basic block. */
4667
4668 for (i = 0; i < DF_REG_SIZE (df); i++)
4669 {
4670 df_reg_chain_verify_unmarked (DF_REG_DEF_CHAIN (i));
4671 df_reg_chain_verify_unmarked (DF_REG_USE_CHAIN (i));
4672 df_reg_chain_verify_unmarked (DF_REG_EQ_USE_CHAIN (i));
4673 }
4674}
Mirror of https://gcc.gnu.org/git/gcc.git