OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [df.h] - Blame information for rev 689

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* Form lists of pseudo register references for autoinc optimization
2
   for GNU compiler.  This is part of flow optimization.
3
   Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008,
4
   2009, 2010, 2011, 2012  Free Software Foundation, Inc.
5
   Originally contributed by Michael P. Hayes
6
             (m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
7
   Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
8
             and Kenneth Zadeck (zadeck@naturalbridge.com).
9
 
10
This file is part of GCC.
11
 
12
GCC is free software; you can redistribute it and/or modify it under
13
the terms of the GNU General Public License as published by the Free
14
Software Foundation; either version 3, or (at your option) any later
15
version.
16
 
17
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18
WARRANTY; without even the implied warranty of MERCHANTABILITY or
19
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
20
for more details.
21
 
22
You should have received a copy of the GNU General Public License
23
along with GCC; see the file COPYING3.  If not see
24
<http://www.gnu.org/licenses/>.  */
25
 
26
#ifndef GCC_DF_H
27
#define GCC_DF_H
28
 
29
#include "bitmap.h"
30
#include "regset.h"
31
#include "sbitmap.h"
32
#include "basic-block.h"
33
#include "alloc-pool.h"
34
#include "timevar.h"
35
 
36
struct dataflow;
37
struct df_d;
38
struct df_problem;
39
struct df_link;
40
struct df_insn_info;
41
union df_ref_d;
42
 
43
/* Data flow problems.  All problems must have a unique id here.  */
44
 
45
/* Scanning is not really a dataflow problem, but it is useful to have
46
   the basic block functions in the vector so that things get done in
47
   a uniform manner.  The last four problems can be added or deleted
48
   at any time are always defined (though LIVE is always there at -O2
49
   or higher); the others are always there.  */
50
#define DF_SCAN    0
51
#define DF_LR      1      /* Live Registers backward. */
52
#define DF_LIVE    2      /* Live Registers & Uninitialized Registers */
53
#define DF_RD      3      /* Reaching Defs. */
54
#define DF_CHAIN   4      /* Def-Use and/or Use-Def Chains. */
55
#define DF_WORD_LR 5      /* Subreg tracking lr.  */
56
#define DF_NOTE    6      /* REG_DEAD and REG_UNUSED notes.  */
57
#define DF_MD      7      /* Multiple Definitions. */
58
 
59
#define DF_LAST_PROBLEM_PLUS1 (DF_MD + 1)
60
 
61
/* Dataflow direction.  */
62
enum df_flow_dir
63
  {
64
    DF_NONE,
65
    DF_FORWARD,
66
    DF_BACKWARD
67
  };
68
 
69
/* Descriminator for the various df_ref types.  */
70
enum df_ref_class {DF_REF_BASE, DF_REF_ARTIFICIAL, DF_REF_REGULAR};
71
 
72
/* The first of these us a set of a registers.  The remaining three
73
   are all uses of a register (the mem_load and mem_store relate to
74
   how the register as an addressing operand).  */
75
enum df_ref_type {DF_REF_REG_DEF, DF_REF_REG_USE,
76
                  DF_REF_REG_MEM_LOAD, DF_REF_REG_MEM_STORE};
77
 
78
enum df_ref_flags
79
  {
80
    /* This flag is set if this ref occurs inside of a conditional
81
       execution instruction.  */
82
    DF_REF_CONDITIONAL = 1 << 0,
83
 
84
    /* If this flag is set for an artificial use or def, that ref
85
       logically happens at the top of the block.  If it is not set
86
       for an artificial use or def, that ref logically happens at the
87
       bottom of the block.  This is never set for regular refs.  */
88
    DF_REF_AT_TOP = 1 << 1,
89
 
90
    /* This flag is set if the use is inside a REG_EQUAL or REG_EQUIV
91
       note.  */
92
    DF_REF_IN_NOTE = 1 << 2,
93
 
94
    /* This bit is true if this ref can make regs_ever_live true for
95
       this regno.  */
96
    DF_HARD_REG_LIVE = 1 << 3,
97
 
98
 
99
    /* This flag is set if this ref is a partial use or def of the
100
       associated register.  */
101
    DF_REF_PARTIAL = 1 << 4,
102
 
103
    /* Read-modify-write refs generate both a use and a def and
104
       these are marked with this flag to show that they are not
105
       independent.  */
106
    DF_REF_READ_WRITE = 1 << 5,
107
 
108
    /* This flag is set if this ref, generally a def, may clobber the
109
       referenced register.  This is generally only set for hard
110
       registers that cross a call site.  With better information
111
       about calls, some of these could be changed in the future to
112
       DF_REF_MUST_CLOBBER.  */
113
    DF_REF_MAY_CLOBBER = 1 << 6,
114
 
115
    /* This flag is set if this ref, generally a def, is a real
116
       clobber. This is not currently set for registers live across a
117
       call because that clobbering may or may not happen.
118
 
119
       Most of the uses of this are with sets that have a
120
       GET_CODE(..)==CLOBBER.  Note that this is set even if the
121
       clobber is to a subreg.  So in order to tell if the clobber
122
       wipes out the entire register, it is necessary to also check
123
       the DF_REF_PARTIAL flag.  */
124
    DF_REF_MUST_CLOBBER = 1 << 7,
125
 
126
 
127
    /* If the ref has one of the following two flags set, then the
128
       struct df_ref can be cast to struct df_ref_extract to access
129
       the width and offset fields.  */
130
 
131
    /* This flag is set if the ref contains a SIGN_EXTRACT.  */
132
    DF_REF_SIGN_EXTRACT = 1 << 8,
133
 
134
    /* This flag is set if the ref contains a ZERO_EXTRACT.  */
135
    DF_REF_ZERO_EXTRACT = 1 << 9,
136
 
137
    /* This flag is set if the ref contains a STRICT_LOW_PART.  */
138
    DF_REF_STRICT_LOW_PART = 1 << 10,
139
 
140
    /* This flag is set if the ref contains a SUBREG.  */
141
    DF_REF_SUBREG = 1 << 11,
142
 
143
 
144
    /* This bit is true if this ref is part of a multiword hardreg.  */
145
    DF_REF_MW_HARDREG = 1 << 12,
146
 
147
    /* This flag is set if this ref is a usage of the stack pointer by
148
       a function call.  */
149
    DF_REF_CALL_STACK_USAGE = 1 << 13,
150
 
151
    /* This flag is used for verification of existing refs. */
152
    DF_REF_REG_MARKER = 1 << 14,
153
 
154
    /* This flag is set if this ref is inside a pre/post modify.  */
155
    DF_REF_PRE_POST_MODIFY = 1 << 15
156
 
157
  };
158
 
159
/* The possible ordering of refs within the df_ref_info.  */
160
enum df_ref_order
161
  {
162
    /* There is not table.  */
163
    DF_REF_ORDER_NO_TABLE,
164
 
165
    /* There is a table of refs but it is not (or no longer) organized
166
       by one of the following methods.  */
167
    DF_REF_ORDER_UNORDERED,
168
    DF_REF_ORDER_UNORDERED_WITH_NOTES,
169
 
170
    /* Organize the table by reg order, all of the refs with regno 0
171
       followed by all of the refs with regno 1 ... .  Within all of
172
       the regs for a particular regno, the refs are unordered.  */
173
    DF_REF_ORDER_BY_REG,
174
 
175
    /* For uses, the refs within eq notes may be added for
176
       DF_REF_ORDER_BY_REG.  */
177
    DF_REF_ORDER_BY_REG_WITH_NOTES,
178
 
179
    /* Organize the refs in insn order.  The insns are ordered within a
180
       block, and the blocks are ordered by FOR_ALL_BB.  */
181
    DF_REF_ORDER_BY_INSN,
182
 
183
    /* For uses, the refs within eq notes may be added for
184
       DF_REF_ORDER_BY_INSN.  */
185
    DF_REF_ORDER_BY_INSN_WITH_NOTES
186
  };
187
 
188
/* Function prototypes added to df_problem instance.  */
189
 
190
/* Allocate the problem specific data.  */
191
typedef void (*df_alloc_function) (bitmap);
192
 
193
/* This function is called if the problem has global data that needs
194
   to be cleared when ever the set of blocks changes.  The bitmap
195
   contains the set of blocks that may require special attention.
196
   This call is only made if some of the blocks are going to change.
197
   If everything is to be deleted, the wholesale deletion mechanisms
198
   apply. */
199
typedef void (*df_reset_function) (bitmap);
200
 
201
/* Free the basic block info.  Called from the block reordering code
202
   to get rid of the blocks that have been squished down.   */
203
typedef void (*df_free_bb_function) (basic_block, void *);
204
 
205
/* Local compute function.  */
206
typedef void (*df_local_compute_function) (bitmap);
207
 
208
/* Init the solution specific data.  */
209
typedef void (*df_init_function) (bitmap);
210
 
211
/* Iterative dataflow function.  */
212
typedef void (*df_dataflow_function) (struct dataflow *, bitmap, int *, int);
213
 
214
/* Confluence operator for blocks with 0 out (or in) edges.  */
215
typedef void (*df_confluence_function_0) (basic_block);
216
 
217
/* Confluence operator for blocks with 1 or more out (or in) edges.
218
   Return true if BB input data has changed.  */
219
typedef bool (*df_confluence_function_n) (edge);
220
 
221
/* Transfer function for blocks.
222
   Return true if BB output data has changed.  */
223
typedef bool (*df_transfer_function) (int);
224
 
225
/* Function to massage the information after the problem solving.  */
226
typedef void (*df_finalizer_function) (bitmap);
227
 
228
/* Function to free all of the problem specific datastructures.  */
229
typedef void (*df_free_function) (void);
230
 
231
/* Function to remove this problem from the stack of dataflow problems
232
   without effecting the other problems in the stack except for those
233
   that depend on this problem.  */
234
typedef void (*df_remove_problem_function) (void);
235
 
236
/* Function to dump basic block independent results to FILE.  */
237
typedef void (*df_dump_problem_function) (FILE *);
238
 
239
/* Function to dump top or bottom of basic block results to FILE.  */
240
typedef void (*df_dump_bb_problem_function) (basic_block, FILE *);
241
 
242
/* Function to dump top or bottom of basic block results to FILE.  */
243
typedef void (*df_verify_solution_start) (void);
244
 
245
/* Function to dump top or bottom of basic block results to FILE.  */
246
typedef void (*df_verify_solution_end) (void);
247
 
248
/* The static description of a dataflow problem to solve.  See above
249
   typedefs for doc for the function fields.  */
250
 
251
struct df_problem {
252
  /* The unique id of the problem.  This is used it index into
253
     df->defined_problems to make accessing the problem data easy.  */
254
  unsigned int id;
255
  enum df_flow_dir dir;                 /* Dataflow direction.  */
256
  df_alloc_function alloc_fun;
257
  df_reset_function reset_fun;
258
  df_free_bb_function free_bb_fun;
259
  df_local_compute_function local_compute_fun;
260
  df_init_function init_fun;
261
  df_dataflow_function dataflow_fun;
262
  df_confluence_function_0 con_fun_0;
263
  df_confluence_function_n con_fun_n;
264
  df_transfer_function trans_fun;
265
  df_finalizer_function finalize_fun;
266
  df_free_function free_fun;
267
  df_remove_problem_function remove_problem_fun;
268
  df_dump_problem_function dump_start_fun;
269
  df_dump_bb_problem_function dump_top_fun;
270
  df_dump_bb_problem_function dump_bottom_fun;
271
  df_verify_solution_start verify_start_fun;
272
  df_verify_solution_end verify_end_fun;
273
  struct df_problem *dependent_problem;
274
  unsigned int block_info_elt_size;
275
 
276
  /* The timevar id associated with this pass.  */
277
  timevar_id_t tv_id;
278
 
279
  /* True if the df_set_blocks should null out the basic block info if
280
     this block drops out of df->blocks_to_analyze.  */
281
  bool free_blocks_on_set_blocks;
282
};
283
 
284
 
285
/* The specific instance of the problem to solve.  */
286
struct dataflow
287
{
288
  struct df_problem *problem;           /* The problem to be solved.  */
289
 
290
  /* Array indexed by bb->index, that contains basic block problem and
291
     solution specific information.  */
292
  void *block_info;
293
  unsigned int block_info_size;
294
 
295
  /* The pool to allocate the block_info from. */
296
  alloc_pool block_pool;
297
 
298
  /* The lr and live problems have their transfer functions recomputed
299
     only if necessary.  This is possible for them because, the
300
     problems are kept active for the entire backend and their
301
     transfer functions are indexed by the REGNO.  These are not
302
     defined for any other problem.  */
303
  bitmap out_of_date_transfer_functions;
304
 
305
  /* Other problem specific data that is not on a per basic block
306
     basis.  The structure is generally defined privately for the
307
     problem.  The exception being the scanning problem where it is
308
     fully public.  */
309
  void *problem_data;
310
 
311
  /* Local flags for some of the problems. */
312
  unsigned int local_flags;
313
 
314
  /* True if this problem of this instance has been initialized.  This
315
     is used by the dumpers to keep garbage out of the dumps if, for
316
     debugging a dump is produced before the first call to
317
     df_analyze after a new problem is added.  */
318
  bool computed;
319
 
320
  /* True if the something has changed which invalidates the dataflow
321
     solutions.  Note that this bit is always true for all problems except
322
     lr and live.  */
323
  bool solutions_dirty;
324
 
325
  /* If true, this pass is deleted by df_finish_pass.  This is never
326
     true for DF_SCAN and DF_LR.  It is true for DF_LIVE if optimize >
327
     1.  It is always true for the other problems.  */
328
  bool optional_p;
329
};
330
 
331
 
332
/* The set of multiword hardregs used as operands to this
333
   instruction. These are factored into individual uses and defs but
334
   the aggregate is still needed to service the REG_DEAD and
335
   REG_UNUSED notes.  */
336
struct df_mw_hardreg
337
{
338
  rtx mw_reg;                   /* The multiword hardreg.  */
339
  /* These two bitfields are intentionally oversized, in the hope that
340
     accesses to 16-bit fields will usually be quicker.  */
341
  ENUM_BITFIELD(df_ref_type) type : 16;
342
                                /* Used to see if the ref is read or write.  */
343
  int flags : 16;               /* Various df_ref_flags.  */
344
  unsigned int start_regno;     /* First word of the multi word subreg.  */
345
  unsigned int end_regno;       /* Last word of the multi word subreg.  */
346
  unsigned int mw_order;        /* Same as df_ref.ref_order.  */
347
};
348
 
349
 
350
/* Define a register reference structure.  One of these is allocated
351
    for every register reference (use or def).  Note some register
352
    references (e.g., post_inc, subreg) generate both a def and a use.  */
353
struct df_base_ref
354
{
355
  /* These three bitfields are intentionally oversized, in the hope that
356
     accesses to 8 and 16-bit fields will usually be quicker.  */
357
  ENUM_BITFIELD(df_ref_class) cl : 8;
358
 
359
  ENUM_BITFIELD(df_ref_type) type : 8;
360
                                /* Type of ref.  */
361
  int flags : 16;               /* Various df_ref_flags.  */
362
  unsigned int regno;           /* The register number referenced.  */
363
  rtx reg;                      /* The register referenced.  */
364
  struct df_link *chain;        /* Head of def-use, use-def.  */
365
  /* Pointer to the insn info of the containing instruction.  FIXME!
366
     Currently this is NULL for artificial refs but this will be used
367
     when FUDs are added.  */
368
  struct df_insn_info *insn_info;
369
  /* For each regno, there are three chains of refs, one for the uses,
370
     the eq_uses and the defs.  These chains go thru the refs
371
     themselves rather than using an external structure.  */
372
  union df_ref_d *next_reg;     /* Next ref with same regno and type.  */
373
  union df_ref_d *prev_reg;     /* Prev ref with same regno and type.  */
374
  /* Location in the ref table.  This is only valid after a call to
375
     df_maybe_reorganize_[use,def]_refs which is an expensive operation.  */
376
  int id;
377
  /* The index at which the operand was scanned in the insn.  This is
378
     used to totally order the refs in an insn.  */
379
  unsigned int ref_order;
380
};
381
 
382
 
383
/* The three types of df_refs.  Note that the df_ref_extract is an
384
   extension of the df_regular_ref, not the df_base_ref.  */
385
struct df_artificial_ref
386
{
387
  struct df_base_ref base;
388
 
389
  /* Artificial refs do not have an insn, so to get the basic block,
390
     it must be explicitly here.  */
391
  basic_block bb;
392
};
393
 
394
 
395
struct df_regular_ref
396
{
397
  struct df_base_ref base;
398
  /* The loc is the address in the insn of the reg.  This is not
399
     defined for special registers, such as clobbers and stack
400
     pointers that are also associated with call insns and so those
401
     just use the base.  */
402
  rtx *loc;
403
};
404
 
405
/* Union of the different kinds of defs/uses placeholders.  */
406
union df_ref_d
407
{
408
  struct df_base_ref base;
409
  struct df_regular_ref regular_ref;
410
  struct df_artificial_ref artificial_ref;
411
};
412
typedef union df_ref_d *df_ref;
413
 
414
 
415
/* One of these structures is allocated for every insn.  */
416
struct df_insn_info
417
{
418
  rtx insn;                     /* The insn this info comes from.  */
419
  df_ref *defs;                 /* Head of insn-def chain.  */
420
  df_ref *uses;                 /* Head of insn-use chain.  */
421
  /* Head of insn-use chain for uses in REG_EQUAL/EQUIV notes.  */
422
  df_ref *eq_uses;
423
  struct df_mw_hardreg **mw_hardregs;
424
  /* The logical uid of the insn in the basic block.  This is valid
425
     after any call to df_analyze but may rot after insns are added,
426
     deleted or moved. */
427
  int luid;
428
};
429
 
430
/* These links are used for ref-ref chains.  Currently only DEF-USE and
431
   USE-DEF chains can be built by DF.  */
432
struct df_link
433
{
434
  df_ref ref;
435
  struct df_link *next;
436
};
437
 
438
 
439
enum df_chain_flags
440
{
441
  /* Flags that control the building of chains.  */
442
  DF_DU_CHAIN      =  1, /* Build DU chains.  */
443
  DF_UD_CHAIN      =  2  /* Build UD chains.  */
444
};
445
 
446
enum df_changeable_flags
447
{
448
  /* Scanning flags.  */
449
  /* Flag to control the running of dce as a side effect of building LR.  */
450
  DF_LR_RUN_DCE           = 1 << 0, /* Run DCE.  */
451
  DF_NO_HARD_REGS         = 1 << 1, /* Skip hard registers in RD and CHAIN Building.  */
452
 
453
  DF_EQ_NOTES             = 1 << 2, /* Build chains with uses present in EQUIV/EQUAL notes. */
454
  DF_NO_REGS_EVER_LIVE    = 1 << 3, /* Do not compute the regs_ever_live.  */
455
 
456
  /* Cause df_insn_rescan df_notes_rescan and df_insn_delete, to
457
  return immediately.  This is used by passes that know how to update
458
  the scanning them selves.  */
459
  DF_NO_INSN_RESCAN       = 1 << 4,
460
 
461
  /* Cause df_insn_rescan df_notes_rescan and df_insn_delete, to
462
  return after marking the insn for later processing.  This allows all
463
  rescans to be batched.  */
464
  DF_DEFER_INSN_RESCAN    = 1 << 5,
465
 
466
  DF_VERIFY_SCHEDULED     = 1 << 6
467
};
468
 
469
/* Two of these structures are inline in df, one for the uses and one
470
   for the defs.  This structure is only contains the refs within the
471
   boundary of the df_set_blocks if that has been defined.  */
472
struct df_ref_info
473
{
474
  df_ref *refs;                 /* Ref table, indexed by id.  */
475
  unsigned int *begin;          /* First ref_index for this pseudo.  */
476
  unsigned int *count;          /* Count of refs for this pseudo.  */
477
  unsigned int refs_size;       /* Size of currently allocated refs table.  */
478
 
479
  /* Table_size is the number of elements in the refs table.  This
480
     will also be the width of the bitvectors in the rd and ru
481
     problems.  Total_size is the number of refs.  These will be the
482
     same if the focus has not been reduced by df_set_blocks.  If the
483
     focus has been reduced, table_size will be smaller since it only
484
     contains the refs in the set blocks.  */
485
  unsigned int table_size;
486
  unsigned int total_size;
487
 
488
  enum df_ref_order ref_order;
489
};
490
 
491
/* Three of these structures are allocated for every pseudo reg. One
492
   for the uses, one for the eq_uses and one for the defs.  */
493
struct df_reg_info
494
{
495
  /* Head of chain for refs of that type and regno.  */
496
  df_ref reg_chain;
497
  /* Number of refs in the chain.  */
498
  unsigned int n_refs;
499
};
500
 
501
 
502
/*----------------------------------------------------------------------------
503
   Problem data for the scanning dataflow problem.  Unlike the other
504
   dataflow problems, the problem data for scanning is fully exposed and
505
   used by owners of the problem.
506
----------------------------------------------------------------------------*/
507
 
508
struct df_d
509
{
510
 
511
  /* The set of problems to be solved is stored in two arrays.  In
512
     PROBLEMS_IN_ORDER, the problems are stored in the order that they
513
     are solved.  This is an internally dense array that may have
514
     nulls at the end of it.  In PROBLEMS_BY_INDEX, the problem is
515
     stored by the value in df_problem.id.  These are used to access
516
     the problem local data without having to search the first
517
     array.  */
518
 
519
  struct dataflow *problems_in_order[DF_LAST_PROBLEM_PLUS1];
520
  struct dataflow *problems_by_index[DF_LAST_PROBLEM_PLUS1];
521
 
522
  /* If not NULL, this subset of blocks of the program to be
523
     considered for analysis.  At certain times, this will contain all
524
     the blocks in the function so it cannot be used as an indicator
525
     of if we are analyzing a subset.  See analyze_subset.  */
526
  bitmap blocks_to_analyze;
527
 
528
  /* The following information is really the problem data for the
529
     scanning instance but it is used too often by the other problems
530
     to keep getting it from there.  */
531
  struct df_ref_info def_info;   /* Def info.  */
532
  struct df_ref_info use_info;   /* Use info.  */
533
 
534
  /* The following three arrays are allocated in parallel.   They contain
535
     the sets of refs of each type for each reg.  */
536
  struct df_reg_info **def_regs;       /* Def reg info.  */
537
  struct df_reg_info **use_regs;       /* Eq_use reg info.  */
538
  struct df_reg_info **eq_use_regs;    /* Eq_use info.  */
539
  unsigned int regs_size;       /* Size of currently allocated regs table.  */
540
  unsigned int regs_inited;     /* Number of regs with reg_infos allocated.  */
541
 
542
 
543
  struct df_insn_info **insns;   /* Insn table, indexed by insn UID.  */
544
  unsigned int insns_size;       /* Size of insn table.  */
545
 
546
  int num_problems_defined;
547
 
548
  bitmap_head hardware_regs_used;     /* The set of hardware registers used.  */
549
  /* The set of hard regs that are in the artificial uses at the end
550
     of a regular basic block.  */
551
  bitmap_head regular_block_artificial_uses;
552
  /* The set of hard regs that are in the artificial uses at the end
553
     of a basic block that has an EH pred.  */
554
  bitmap_head eh_block_artificial_uses;
555
  /* The set of hardware registers live on entry to the function.  */
556
  bitmap entry_block_defs;
557
  bitmap exit_block_uses;        /* The set of hardware registers used in exit block.  */
558
 
559
  /* Insns to delete, rescan or reprocess the notes at next
560
     df_rescan_all or df_process_deferred_rescans. */
561
  bitmap_head insns_to_delete;
562
  bitmap_head insns_to_rescan;
563
  bitmap_head insns_to_notes_rescan;
564
  int *postorder;                /* The current set of basic blocks
565
                                    in reverse postorder.  */
566
  int *postorder_inverted;       /* The current set of basic blocks
567
                                    in reverse postorder of inverted CFG.  */
568
  int n_blocks;                  /* The number of blocks in reverse postorder.  */
569
  int n_blocks_inverted;         /* The number of blocks
570
                                    in reverse postorder of inverted CFG.  */
571
 
572
  /* An array [FIRST_PSEUDO_REGISTER], indexed by regno, of the number
573
     of refs that qualify as being real hard regs uses.  Artificial
574
     uses and defs as well as refs in eq notes are ignored.  If the
575
     ref is a def, it cannot be a MAY_CLOBBER def.  If the ref is a
576
     use, it cannot be the emim_reg_set or be the frame or arg pointer
577
     register.  Uses in debug insns are ignored.
578
 
579
     IT IS NOT ACCEPTABLE TO MANUALLY CHANGE THIS ARRAY.  This array
580
     always reflects the actual number of refs in the insn stream that
581
     satisfy the above criteria.  */
582
  unsigned int *hard_regs_live_count;
583
 
584
  /* This counter provides a way to totally order refs without using
585
     addresses.  It is incremented whenever a ref is created.  */
586
  unsigned int ref_order;
587
 
588
  /* Problem specific control information.  This is a combination of
589
     enum df_changeable_flags values.  */
590
  int changeable_flags : 8;
591
 
592
  /* If this is true, then only a subset of the blocks of the program
593
     is considered to compute the solutions of dataflow problems.  */
594
  bool analyze_subset;
595
 
596
  /* True if someone added or deleted something from regs_ever_live so
597
     that the entry and exit blocks need be reprocessed.  */
598
  bool redo_entry_and_exit;
599
};
600
 
601
#define DF_SCAN_BB_INFO(BB) (df_scan_get_bb_info((BB)->index))
602
#define DF_RD_BB_INFO(BB) (df_rd_get_bb_info((BB)->index))
603
#define DF_LR_BB_INFO(BB) (df_lr_get_bb_info((BB)->index))
604
#define DF_LIVE_BB_INFO(BB) (df_live_get_bb_info((BB)->index))
605
#define DF_WORD_LR_BB_INFO(BB) (df_word_lr_get_bb_info((BB)->index))
606
#define DF_MD_BB_INFO(BB) (df_md_get_bb_info((BB)->index))
607
 
608
/* Most transformations that wish to use live register analysis will
609
   use these macros.  This info is the and of the lr and live sets.  */
610
#define DF_LIVE_IN(BB) (&DF_LIVE_BB_INFO(BB)->in)
611
#define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO(BB)->out)
612
 
613
/* These macros are used by passes that are not tolerant of
614
   uninitialized variables.  This intolerance should eventually
615
   be fixed.  */
616
#define DF_LR_IN(BB) (&DF_LR_BB_INFO(BB)->in)
617
#define DF_LR_OUT(BB) (&DF_LR_BB_INFO(BB)->out)
618
 
619
/* These macros are used by passes that are not tolerant of
620
   uninitialized variables.  This intolerance should eventually
621
   be fixed.  */
622
#define DF_WORD_LR_IN(BB) (&DF_WORD_LR_BB_INFO(BB)->in)
623
#define DF_WORD_LR_OUT(BB) (&DF_WORD_LR_BB_INFO(BB)->out)
624
 
625
/* Macros to access the elements within the ref structure.  */
626
 
627
 
628
#define DF_REF_REAL_REG(REF) (GET_CODE ((REF)->base.reg) == SUBREG \
629
                                ? SUBREG_REG ((REF)->base.reg) : ((REF)->base.reg))
630
#define DF_REF_REGNO(REF) ((REF)->base.regno)
631
#define DF_REF_REAL_LOC(REF) (GET_CODE (*((REF)->regular_ref.loc)) == SUBREG \
632
                               ? &SUBREG_REG (*((REF)->regular_ref.loc)) : ((REF)->regular_ref.loc))
633
#define DF_REF_REG(REF) ((REF)->base.reg)
634
#define DF_REF_LOC(REF) (DF_REF_CLASS(REF) == DF_REF_REGULAR ? \
635
                         (REF)->regular_ref.loc : NULL)
636
#define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL(REF) ? \
637
                        (REF)->artificial_ref.bb : BLOCK_FOR_INSN (DF_REF_INSN(REF)))
638
#define DF_REF_BBNO(REF) (DF_REF_BB (REF)->index)
639
#define DF_REF_INSN_INFO(REF) ((REF)->base.insn_info)
640
#define DF_REF_INSN(REF) ((REF)->base.insn_info->insn)
641
#define DF_REF_INSN_UID(REF) (INSN_UID (DF_REF_INSN(REF)))
642
#define DF_REF_CLASS(REF) ((REF)->base.cl)
643
#define DF_REF_TYPE(REF) ((REF)->base.type)
644
#define DF_REF_CHAIN(REF) ((REF)->base.chain)
645
#define DF_REF_ID(REF) ((REF)->base.id)
646
#define DF_REF_FLAGS(REF) ((REF)->base.flags)
647
#define DF_REF_FLAGS_IS_SET(REF, v) ((DF_REF_FLAGS (REF) & (v)) != 0)
648
#define DF_REF_FLAGS_SET(REF, v) (DF_REF_FLAGS (REF) |= (v))
649
#define DF_REF_FLAGS_CLEAR(REF, v) (DF_REF_FLAGS (REF) &= ~(v))
650
#define DF_REF_ORDER(REF) ((REF)->base.ref_order)
651
/* If DF_REF_IS_ARTIFICIAL () is true, this is not a real
652
   definition/use, but an artificial one created to model always live
653
   registers, eh uses, etc.  */
654
#define DF_REF_IS_ARTIFICIAL(REF) (DF_REF_CLASS(REF) == DF_REF_ARTIFICIAL)
655
#define DF_REF_REG_MARK(REF) (DF_REF_FLAGS_SET ((REF),DF_REF_REG_MARKER))
656
#define DF_REF_REG_UNMARK(REF) (DF_REF_FLAGS_CLEAR ((REF),DF_REF_REG_MARKER))
657
#define DF_REF_IS_REG_MARKED(REF) (DF_REF_FLAGS_IS_SET ((REF),DF_REF_REG_MARKER))
658
#define DF_REF_NEXT_REG(REF) ((REF)->base.next_reg)
659
#define DF_REF_PREV_REG(REF) ((REF)->base.prev_reg)
660
/* The following two macros may only be applied if one of
661
   DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT is true. */
662
#define DF_REF_EXTRACT_WIDTH(REF) ((REF)->extract_ref.width)
663
#define DF_REF_EXTRACT_OFFSET(REF) ((REF)->extract_ref.offset)
664
#define DF_REF_EXTRACT_MODE(REF) ((REF)->extract_ref.mode)
665
 
666
/* Macros to determine the reference type.  */
667
#define DF_REF_REG_DEF_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_DEF)
668
#define DF_REF_REG_USE_P(REF) ((REF) && !DF_REF_REG_DEF_P (REF))
669
#define DF_REF_REG_MEM_STORE_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_MEM_STORE)
670
#define DF_REF_REG_MEM_LOAD_P(REF) (DF_REF_TYPE (REF) == DF_REF_REG_MEM_LOAD)
671
#define DF_REF_REG_MEM_P(REF) (DF_REF_REG_MEM_STORE_P (REF) \
672
                               || DF_REF_REG_MEM_LOAD_P (REF))
673
 
674
#define DF_MWS_REG_DEF_P(MREF) (DF_MWS_TYPE (MREF) == DF_REF_REG_DEF)
675
#define DF_MWS_REG_USE_P(MREF) ((MREF) && !DF_MWS_REG_DEF_P (MREF))
676
#define DF_MWS_TYPE(MREF) ((MREF)->type)
677
 
678
/* Macros to get the refs out of def_info or use_info refs table.  If
679
   the focus of the dataflow has been set to some subset of blocks
680
   with df_set_blocks, these macros will only find the uses and defs
681
   in that subset of blocks.
682
 
683
   These macros should be used with care.  The def macros are only
684
   usable after a call to df_maybe_reorganize_def_refs and the use
685
   macros are only usable after a call to
686
   df_maybe_reorganize_use_refs.  HOWEVER, BUILDING AND USING THESE
687
   ARRAYS ARE A CACHE LOCALITY KILLER.  */
688
 
689
#define DF_DEFS_TABLE_SIZE() (df->def_info.table_size)
690
#define DF_DEFS_GET(ID) (df->def_info.refs[(ID)])
691
#define DF_DEFS_SET(ID,VAL) (df->def_info.refs[(ID)]=(VAL))
692
#define DF_DEFS_COUNT(ID) (df->def_info.count[(ID)])
693
#define DF_DEFS_BEGIN(ID) (df->def_info.begin[(ID)])
694
#define DF_USES_TABLE_SIZE() (df->use_info.table_size)
695
#define DF_USES_GET(ID) (df->use_info.refs[(ID)])
696
#define DF_USES_SET(ID,VAL) (df->use_info.refs[(ID)]=(VAL))
697
#define DF_USES_COUNT(ID) (df->use_info.count[(ID)])
698
#define DF_USES_BEGIN(ID) (df->use_info.begin[(ID)])
699
 
700
/* Macros to access the register information from scan dataflow record.  */
701
 
702
#define DF_REG_SIZE(DF) (df->regs_inited)
703
#define DF_REG_DEF_GET(REG) (df->def_regs[(REG)])
704
#define DF_REG_DEF_CHAIN(REG) (df->def_regs[(REG)]->reg_chain)
705
#define DF_REG_DEF_COUNT(REG) (df->def_regs[(REG)]->n_refs)
706
#define DF_REG_USE_GET(REG) (df->use_regs[(REG)])
707
#define DF_REG_USE_CHAIN(REG) (df->use_regs[(REG)]->reg_chain)
708
#define DF_REG_USE_COUNT(REG) (df->use_regs[(REG)]->n_refs)
709
#define DF_REG_EQ_USE_GET(REG) (df->eq_use_regs[(REG)])
710
#define DF_REG_EQ_USE_CHAIN(REG) (df->eq_use_regs[(REG)]->reg_chain)
711
#define DF_REG_EQ_USE_COUNT(REG) (df->eq_use_regs[(REG)]->n_refs)
712
 
713
/* Macros to access the elements within the reg_info structure table.  */
714
 
715
#define DF_REGNO_FIRST_DEF(REGNUM) \
716
(DF_REG_DEF_GET(REGNUM) ? DF_REG_DEF_GET(REGNUM) : 0)
717
#define DF_REGNO_LAST_USE(REGNUM) \
718
(DF_REG_USE_GET(REGNUM) ? DF_REG_USE_GET(REGNUM) : 0)
719
 
720
/* Macros to access the elements within the insn_info structure table.  */
721
 
722
#define DF_INSN_SIZE() ((df)->insns_size)
723
#define DF_INSN_INFO_GET(INSN) (df->insns[(INSN_UID(INSN))])
724
#define DF_INSN_INFO_SET(INSN,VAL) (df->insns[(INSN_UID (INSN))]=(VAL))
725
#define DF_INSN_INFO_LUID(II) ((II)->luid)
726
#define DF_INSN_INFO_DEFS(II) ((II)->defs)
727
#define DF_INSN_INFO_USES(II) ((II)->uses)
728
#define DF_INSN_INFO_EQ_USES(II) ((II)->eq_uses)
729
 
730
#define DF_INSN_LUID(INSN) (DF_INSN_INFO_LUID (DF_INSN_INFO_GET(INSN)))
731
#define DF_INSN_DEFS(INSN) (DF_INSN_INFO_DEFS (DF_INSN_INFO_GET(INSN)))
732
#define DF_INSN_USES(INSN) (DF_INSN_INFO_USES (DF_INSN_INFO_GET(INSN)))
733
#define DF_INSN_EQ_USES(INSN) (DF_INSN_INFO_EQ_USES (DF_INSN_INFO_GET(INSN)))
734
 
735
#define DF_INSN_UID_GET(UID) (df->insns[(UID)])
736
#define DF_INSN_UID_SET(UID,VAL) (df->insns[(UID)]=(VAL))
737
#define DF_INSN_UID_SAFE_GET(UID) (((unsigned)(UID) < DF_INSN_SIZE())   \
738
                                     ? DF_INSN_UID_GET (UID) \
739
                                     : NULL)
740
#define DF_INSN_UID_LUID(INSN) (DF_INSN_UID_GET(INSN)->luid)
741
#define DF_INSN_UID_DEFS(INSN) (DF_INSN_UID_GET(INSN)->defs)
742
#define DF_INSN_UID_USES(INSN) (DF_INSN_UID_GET(INSN)->uses)
743
#define DF_INSN_UID_EQ_USES(INSN) (DF_INSN_UID_GET(INSN)->eq_uses)
744
#define DF_INSN_UID_MWS(INSN) (DF_INSN_UID_GET(INSN)->mw_hardregs)
745
 
746
/* An obstack for bitmap not related to specific dataflow problems.
747
   This obstack should e.g. be used for bitmaps with a short life time
748
   such as temporary bitmaps.  This obstack is declared in df-core.c.  */
749
 
750
extern bitmap_obstack df_bitmap_obstack;
751
 
752
 
753
/* One of these structures is allocated for every basic block.  */
754
struct df_scan_bb_info
755
{
756
  /* The entry block has many artificial defs and these are at the
757
     bottom of the block.
758
 
759
     Blocks that are targets of exception edges may have some
760
     artificial defs.  These are logically located at the top of the
761
     block.
762
 
763
     Blocks that are the targets of non-local goto's have the hard
764
     frame pointer defined at the top of the block.  */
765
  df_ref *artificial_defs;
766
 
767
  /* Blocks that are targets of exception edges may have some
768
     artificial uses.  These are logically at the top of the block.
769
 
770
     Most blocks have artificial uses at the bottom of the block.  */
771
  df_ref *artificial_uses;
772
};
773
 
774
 
775
/* Reaching definitions.  All bitmaps are indexed by the id field of
776
   the ref except sparse_kill which is indexed by regno.  */
777
struct df_rd_bb_info
778
{
779
  /* Local sets to describe the basic blocks.   */
780
  bitmap_head kill;
781
  bitmap_head sparse_kill;
782
  bitmap_head gen;   /* The set of defs generated in this block.  */
783
 
784
  /* The results of the dataflow problem.  */
785
  bitmap_head in;    /* At the top of the block.  */
786
  bitmap_head out;   /* At the bottom of the block.  */
787
};
788
 
789
 
790
/* Multiple reaching definitions.  All bitmaps are referenced by the
791
   register number.  */
792
 
793
struct df_md_bb_info
794
{
795
  /* Local sets to describe the basic blocks.  */
796
  bitmap_head gen;    /* Partial/conditional definitions live at BB out.  */
797
  bitmap_head kill;   /* Other definitions that are live at BB out.  */
798
  bitmap_head init;   /* Definitions coming from dominance frontier edges. */
799
 
800
  /* The results of the dataflow problem.  */
801
  bitmap_head in;    /* Just before the block itself. */
802
  bitmap_head out;   /* At the bottom of the block.  */
803
};
804
 
805
 
806
/* Live registers, a backwards dataflow problem.  All bitmaps are
807
   referenced by the register number.  */
808
 
809
struct df_lr_bb_info
810
{
811
  /* Local sets to describe the basic blocks.  */
812
  bitmap_head def;   /* The set of registers set in this block
813
                        - except artificial defs at the top.  */
814
  bitmap_head use;   /* The set of registers used in this block.  */
815
 
816
  /* The results of the dataflow problem.  */
817
  bitmap_head in;    /* Just before the block itself. */
818
  bitmap_head out;   /* At the bottom of the block.  */
819
};
820
 
821
 
822
/* Uninitialized registers.  All bitmaps are referenced by the
823
   register number.  Anded results of the forwards and backward live
824
   info.  Note that the forwards live information is not available
825
   separately.  */
826
struct df_live_bb_info
827
{
828
  /* Local sets to describe the basic blocks.  */
829
  bitmap_head kill;  /* The set of registers unset in this block.  Calls,
830
                        for instance, unset registers.  */
831
  bitmap_head gen;   /* The set of registers set in this block.  */
832
 
833
  /* The results of the dataflow problem.  */
834
  bitmap_head in;    /* At the top of the block.  */
835
  bitmap_head out;   /* At the bottom of the block.  */
836
};
837
 
838
 
839
/* Live registers, a backwards dataflow problem.  These bitmaps are
840
   indexed by 2 * regno for each pseudo and have two entries for each
841
   pseudo.  Only pseudos that have a size of 2 * UNITS_PER_WORD are
842
   meaningfully tracked.  */
843
 
844
struct df_word_lr_bb_info
845
{
846
  /* Local sets to describe the basic blocks.  */
847
  bitmap_head def;   /* The set of registers set in this block
848
                        - except artificial defs at the top.  */
849
  bitmap_head use;   /* The set of registers used in this block.  */
850
 
851
  /* The results of the dataflow problem.  */
852
  bitmap_head in;    /* Just before the block itself. */
853
  bitmap_head out;   /* At the bottom of the block.  */
854
};
855
 
856
 
857
/* This is used for debugging and for the dumpers to find the latest
858
   instance so that the df info can be added to the dumps.  This
859
   should not be used by regular code.  */
860
extern struct df_d *df;
861
#define df_scan    (df->problems_by_index[DF_SCAN])
862
#define df_rd      (df->problems_by_index[DF_RD])
863
#define df_lr      (df->problems_by_index[DF_LR])
864
#define df_live    (df->problems_by_index[DF_LIVE])
865
#define df_chain   (df->problems_by_index[DF_CHAIN])
866
#define df_word_lr (df->problems_by_index[DF_WORD_LR])
867
#define df_note    (df->problems_by_index[DF_NOTE])
868
#define df_md      (df->problems_by_index[DF_MD])
869
 
870
/* This symbol turns on checking that each modification of the cfg has
871
  been identified to the appropriate df routines.  It is not part of
872
  verification per se because the check that the final solution has
873
  not changed covers this.  However, if the solution is not being
874
  properly recomputed because the cfg is being modified, adding in
875
  calls to df_check_cfg_clean can be used to find the source of that
876
  kind of problem.  */
877
#if 0
878
#define DF_DEBUG_CFG
879
#endif
880
 
881
 
882
/* Functions defined in df-core.c.  */
883
 
884
extern void df_add_problem (struct df_problem *);
885
extern int df_set_flags (int);
886
extern int df_clear_flags (int);
887
extern void df_set_blocks (bitmap);
888
extern void df_remove_problem (struct dataflow *);
889
extern void df_finish_pass (bool);
890
extern void df_analyze_problem (struct dataflow *, bitmap, int *, int);
891
extern void df_analyze (void);
892
extern int df_get_n_blocks (enum df_flow_dir);
893
extern int *df_get_postorder (enum df_flow_dir);
894
extern void df_simple_dataflow (enum df_flow_dir, df_init_function,
895
                                df_confluence_function_0, df_confluence_function_n,
896
                                df_transfer_function, bitmap, int *, int);
897
extern void df_mark_solutions_dirty (void);
898
extern bool df_get_bb_dirty (basic_block);
899
extern void df_set_bb_dirty (basic_block);
900
extern void df_compact_blocks (void);
901
extern void df_bb_replace (int, basic_block);
902
extern void df_bb_delete (int);
903
extern void df_verify (void);
904
#ifdef DF_DEBUG_CFG
905
extern void df_check_cfg_clean (void);
906
#endif
907
extern df_ref df_bb_regno_first_def_find (basic_block, unsigned int);
908
extern df_ref df_bb_regno_last_def_find (basic_block, unsigned int);
909
extern df_ref df_find_def (rtx, rtx);
910
extern bool df_reg_defined (rtx, rtx);
911
extern df_ref df_find_use (rtx, rtx);
912
extern bool df_reg_used (rtx, rtx);
913
extern void df_worklist_dataflow (struct dataflow *,bitmap, int *, int);
914
extern void df_print_regset (FILE *file, bitmap r);
915
extern void df_print_word_regset (FILE *file, bitmap r);
916
extern void df_dump (FILE *);
917
extern void df_dump_region (FILE *);
918
extern void df_dump_start (FILE *);
919
extern void df_dump_top (basic_block, FILE *);
920
extern void df_dump_bottom (basic_block, FILE *);
921
extern void df_refs_chain_dump (df_ref *, bool, FILE *);
922
extern void df_regs_chain_dump (df_ref,  FILE *);
923
extern void df_insn_debug (rtx, bool, FILE *);
924
extern void df_insn_debug_regno (rtx, FILE *);
925
extern void df_regno_debug (unsigned int, FILE *);
926
extern void df_ref_debug (df_ref, FILE *);
927
extern void debug_df_insn (rtx);
928
extern void debug_df_regno (unsigned int);
929
extern void debug_df_reg (rtx);
930
extern void debug_df_defno (unsigned int);
931
extern void debug_df_useno (unsigned int);
932
extern void debug_df_ref (df_ref);
933
extern void debug_df_chain (struct df_link *);
934
 
935
/* Functions defined in df-problems.c. */
936
 
937
extern struct df_link *df_chain_create (df_ref, df_ref);
938
extern void df_chain_unlink (df_ref);
939
extern void df_chain_copy (df_ref, struct df_link *);
940
extern bitmap df_get_live_in (basic_block);
941
extern bitmap df_get_live_out (basic_block);
942
extern void df_grow_bb_info (struct dataflow *);
943
extern void df_chain_dump (struct df_link *, FILE *);
944
extern void df_print_bb_index (basic_block bb, FILE *file);
945
extern void df_rd_add_problem (void);
946
extern void df_rd_simulate_artificial_defs_at_top (basic_block, bitmap);
947
extern void df_rd_simulate_one_insn (basic_block, rtx, bitmap);
948
extern void df_lr_add_problem (void);
949
extern void df_lr_verify_transfer_functions (void);
950
extern void df_live_verify_transfer_functions (void);
951
extern void df_live_add_problem (void);
952
extern void df_live_set_all_dirty (void);
953
extern void df_chain_add_problem (unsigned int);
954
extern void df_word_lr_add_problem (void);
955
extern bool df_word_lr_mark_ref (df_ref, bool, bitmap);
956
extern bool df_word_lr_simulate_defs (rtx, bitmap);
957
extern void df_word_lr_simulate_uses (rtx, bitmap);
958
extern void df_word_lr_simulate_artificial_refs_at_top (basic_block, bitmap);
959
extern void df_word_lr_simulate_artificial_refs_at_end (basic_block, bitmap);
960
extern void df_note_add_problem (void);
961
extern void df_md_add_problem (void);
962
extern void df_md_simulate_artificial_defs_at_top (basic_block, bitmap);
963
extern void df_md_simulate_one_insn (basic_block, rtx, bitmap);
964
extern void df_simulate_find_noclobber_defs (rtx, bitmap);
965
extern void df_simulate_find_defs (rtx, bitmap);
966
extern void df_simulate_defs (rtx, bitmap);
967
extern void df_simulate_uses (rtx, bitmap);
968
extern void df_simulate_initialize_backwards (basic_block, bitmap);
969
extern void df_simulate_one_insn_backwards (basic_block, rtx, bitmap);
970
extern void df_simulate_finalize_backwards (basic_block, bitmap);
971
extern void df_simulate_initialize_forwards (basic_block, bitmap);
972
extern void df_simulate_one_insn_forwards (basic_block, rtx, bitmap);
973
extern void simulate_backwards_to_point (basic_block, regset, rtx);
974
extern bool can_move_insns_across (rtx, rtx, rtx, rtx, basic_block, regset,
975
                                   regset, rtx *);
976
/* Functions defined in df-scan.c.  */
977
 
978
extern void df_scan_alloc (bitmap);
979
extern void df_scan_add_problem (void);
980
extern void df_grow_reg_info (void);
981
extern void df_grow_insn_info (void);
982
extern void df_scan_blocks (void);
983
extern df_ref df_ref_create (rtx, rtx *, rtx,basic_block,
984
                             enum df_ref_type, int ref_flags);
985
extern void df_uses_create (rtx *, rtx, int);
986
extern void df_ref_remove (df_ref);
987
extern struct df_insn_info * df_insn_create_insn_record (rtx);
988
extern void df_insn_delete (basic_block, unsigned int);
989
extern void df_bb_refs_record (int, bool);
990
extern bool df_insn_rescan (rtx);
991
extern bool df_insn_rescan_debug_internal (rtx);
992
extern void df_insn_rescan_all (void);
993
extern void df_process_deferred_rescans (void);
994
extern void df_recompute_luids (basic_block);
995
extern void df_insn_change_bb (rtx, basic_block);
996
extern void df_maybe_reorganize_use_refs (enum df_ref_order);
997
extern void df_maybe_reorganize_def_refs (enum df_ref_order);
998
extern void df_ref_change_reg_with_loc (int, int, rtx);
999
extern void df_notes_rescan (rtx);
1000
extern void df_hard_reg_init (void);
1001
extern void df_update_entry_block_defs (void);
1002
extern void df_update_exit_block_uses (void);
1003
extern void df_update_entry_exit_and_calls (void);
1004
extern bool df_hard_reg_used_p (unsigned int);
1005
extern unsigned int df_hard_reg_used_count (unsigned int);
1006
extern bool df_regs_ever_live_p (unsigned int);
1007
extern void df_set_regs_ever_live (unsigned int, bool);
1008
extern void df_compute_regs_ever_live (bool);
1009
extern bool df_read_modify_subreg_p (rtx);
1010
extern void df_scan_verify (void);
1011
 
1012
/* Get basic block info.  */
1013
 
1014
static inline struct df_scan_bb_info *
1015
df_scan_get_bb_info (unsigned int index)
1016
{
1017
  if (index < df_scan->block_info_size)
1018
    return &((struct df_scan_bb_info *) df_scan->block_info)[index];
1019
  else
1020
    return NULL;
1021
}
1022
 
1023
static inline struct df_rd_bb_info *
1024
df_rd_get_bb_info (unsigned int index)
1025
{
1026
  if (index < df_rd->block_info_size)
1027
    return &((struct df_rd_bb_info *) df_rd->block_info)[index];
1028
  else
1029
    return NULL;
1030
}
1031
 
1032
static inline struct df_lr_bb_info *
1033
df_lr_get_bb_info (unsigned int index)
1034
{
1035
  if (index < df_lr->block_info_size)
1036
    return &((struct df_lr_bb_info *) df_lr->block_info)[index];
1037
  else
1038
    return NULL;
1039
}
1040
 
1041
static inline struct df_md_bb_info *
1042
df_md_get_bb_info (unsigned int index)
1043
{
1044
  if (index < df_md->block_info_size)
1045
    return &((struct df_md_bb_info *) df_md->block_info)[index];
1046
  else
1047
    return NULL;
1048
}
1049
 
1050
static inline struct df_live_bb_info *
1051
df_live_get_bb_info (unsigned int index)
1052
{
1053
  if (index < df_live->block_info_size)
1054
    return &((struct df_live_bb_info *) df_live->block_info)[index];
1055
  else
1056
    return NULL;
1057
}
1058
 
1059
static inline struct df_word_lr_bb_info *
1060
df_word_lr_get_bb_info (unsigned int index)
1061
{
1062
  if (index < df_word_lr->block_info_size)
1063
    return &((struct df_word_lr_bb_info *) df_word_lr->block_info)[index];
1064
  else
1065
    return NULL;
1066
}
1067
 
1068
/* Get the artificial defs for a basic block.  */
1069
 
1070
static inline df_ref *
1071
df_get_artificial_defs (unsigned int bb_index)
1072
{
1073
  return df_scan_get_bb_info (bb_index)->artificial_defs;
1074
}
1075
 
1076
 
1077
/* Get the artificial uses for a basic block.  */
1078
 
1079
static inline df_ref *
1080
df_get_artificial_uses (unsigned int bb_index)
1081
{
1082
  return df_scan_get_bb_info (bb_index)->artificial_uses;
1083
}
1084
 
1085
 
1086
/* web */
1087
 
1088
/* This entry is allocated for each reference in the insn stream.  */
1089
struct web_entry
1090
{
1091
  /* Pointer to the parent in the union/find tree.  */
1092
  struct web_entry *pred;
1093
  /* Newly assigned register to the entry.  Set only for roots.  */
1094
  rtx reg;
1095
  void* extra_info;
1096
};
1097
 
1098
extern struct web_entry *unionfind_root (struct web_entry *);
1099
extern bool unionfind_union (struct web_entry *, struct web_entry *);
1100
extern void union_defs (df_ref, struct web_entry *,
1101
                        unsigned int *used, struct web_entry *,
1102
                        bool (*fun) (struct web_entry *, struct web_entry *));
1103
 
1104
#endif /* GCC_DF_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.