gcc/df.h

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