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