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