gcc/ra.h

   1 /* Graph coloring register allocator
   2    Copyright (C) 2001, 2002 Free Software Foundation, Inc.
   3    Contributed by Michael Matz <matz@suse.de>
   4    and Daniel Berlin <dan@cgsoftware.com>.
   5
   6    This file is part of GCC.
   7
   8    GCC is free software; you can redistribute it and/or modify it under the
   9    terms of the GNU General Public License as published by the Free Software
  10    Foundation; either version 2, or (at your option) any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  15    details.
  16
  17    You should have received a copy of the GNU General Public License along
  18    with GCC; see the file COPYING.  If not, write to the Free Software
  19    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* Double linked list to implement the per-type lists of webs
  22    and moves.  */
  23 struct dlist
  24 {
  25   struct dlist *prev;
  26   struct dlist *next;
  27   union
  28     {
  29       struct web *web;
  30       struct move *move;
  31     } value;
  32 };
  33 /* Simple helper macros for ease of misuse.  */
  34 #define DLIST_WEB(l) ((l)->value.web)
  35 #define DLIST_MOVE(l) ((l)->value.move)
  36
  37 /* Classification of a given node (i.e. what state it's in).  */
  38 enum node_type
  39 {
  40   INITIAL = 0, FREE,
  41   PRECOLORED,
  42   SIMPLIFY, SIMPLIFY_SPILL, SIMPLIFY_FAT, FREEZE, SPILL,
  43   SELECT,
  44   SPILLED, COALESCED, COLORED,
  45   LAST_NODE_TYPE
  46 };
  47
  48 /* A list of conflict bitmaps, factorized on the exact part of
  49    the source, which conflicts with the DEFs, whose ID are noted in
  50    the bitmap.  This is used while building web-parts with conflicts.  */
  51 struct tagged_conflict
  52 {
  53   struct tagged_conflict *next;
  54   bitmap conflicts;
  55
  56   /* If the part of source identified by size S, byteoffset O conflicts,
  57      then size_word == S | (O << 16).  */
  58   unsigned int size_word;
  59 };
  60
  61 /* Such a structure is allocated initially for each def and use.
  62    In the process of building the interference graph web parts are
  63    connected together, if they have common instructions and reference the
  64    same register.  That way live ranges are build (by connecting defs and
  65    uses) and implicitely complete webs (by connecting web parts in common
  66    uses).  */
  67 struct web_part
  68 {
  69   /* The def or use for this web part.  */
  70   struct ref *ref;
  71   /* The uplink implementing the disjoint set.  */
  72   struct web_part *uplink;
  73
  74   /* Here dynamic information associated with each def/use is saved.
  75      This all is only valid for root web parts (uplink==NULL).
  76      That's the information we need to merge, if web parts are unioned.  */
  77
  78   /* Number of spanned insns containing any deaths.  */
  79   unsigned int spanned_deaths;
  80   /* The list of bitmaps of DEF ID's with which this part conflicts.  */
  81   struct tagged_conflict *sub_conflicts;
  82   /* If there's any call_insn, while this part is live.  */
  83   unsigned int crosses_call : 1;
  84 };
  85
  86 /* Web structure used to store info about connected live ranges.
  87    This represents the nodes of the interference graph, which gets
  88    colored.  It can also hold subwebs, which are contained in webs
  89    and represent subregs.  */
  90 struct web
  91 {
  92   /* Unique web ID.  */
  93   unsigned int id;
  94
  95   /* Register number of the live range's variable.  */
  96   unsigned int regno;
  97
  98   /* How many insns containing deaths do we span?  */
  99   unsigned int span_deaths;
 100
 101   /* Spill_temp indicates if this web was part of a web spilled in the
 102      last iteration, or or reasons why this shouldn't be spilled again.
 103      1 spill web, can't be spilled.
 104      2 big spill web (live over some deaths).  Discouraged, but not
 105        impossible to spill again.
 106      3 short web (spans no deaths), can't be spilled.  */
 107   unsigned int spill_temp;
 108
 109   /* When coalescing we might change spill_temp.  If breaking aliases we
 110      need to restore it.  */
 111   unsigned int orig_spill_temp;
 112
 113   /* Cost of spilling.  */
 114   unsigned HOST_WIDE_INT spill_cost;
 115   unsigned HOST_WIDE_INT orig_spill_cost;
 116
 117   /* How many webs are aliased to us?  */
 118   unsigned int num_aliased;
 119
 120   /* The color we got.  This is a hardreg number.  */
 121   int color;
 122   /* 1 + the color this web got in the last pass.  If it hadn't got a color,
 123      or we are in the first pass, or this web is a new one, this is zero.  */
 124   int old_color;
 125
 126   /* Now follow some flags characterizing the web.  */
 127
 128   /* Nonzero, if we should use usable_regs for this web, instead of
 129      preferred_class() or alternate_class().  */
 130   unsigned int use_my_regs:1;
 131
 132   /* Nonzero if we selected this web as possible spill candidate in
 133      select_spill().  */
 134   unsigned int was_spilled:1;
 135
 136   /* We need to distinguish also webs which are targets of coalescing
 137      (all x with some y, so that x==alias(y)), but the alias field is
 138      only set for sources of coalescing.  This flag is set for all webs
 139      involved in coalescing in some way.  */
 140   unsigned int is_coalesced:1;
 141
 142   /* Nonzero, if this web (or subweb) doesn't correspond with any of
 143      the current functions actual use of reg rtx.  Happens e.g. with
 144      conflicts to a web, of which only a part was still undefined at the
 145      point of that conflict.  In this case we construct a subweb
 146      representing these yet undefined bits to have a target for the
 147      conflict.  Suppose e.g. this sequence:
 148      (set (reg:DI x) ...)
 149      (set (reg:SI y) ...)
 150      (set (subreg:SI (reg:DI x) 0) ...)
 151      (use (reg:DI x))
 152      Here x only partly conflicts with y.  Namely only (subreg:SI (reg:DI x)
 153      1) conflicts with it, but this rtx doesn't show up in the program.  For
 154      such things an "artificial" subweb is built, and this flag is true for
 155      them.  */
 156   unsigned int artificial:1;
 157
 158   /* Nonzero if we span a call_insn.  */
 159   unsigned int crosses_call:1;
 160
 161   /* Wether the web is involved in a move insn.  */
 162   unsigned int move_related:1;
 163
 164   /* 1 when this web (or parts thereof) are live over an abnormal edge.  */
 165   unsigned int live_over_abnormal:1;
 166
 167   /* Nonzero if this web is used in subregs where the mode change
 168      was illegal for hardregs in CLASS_CANNOT_CHANGE_MODE.  */
 169   unsigned int mode_changed:1;
 170
 171   /* Nonzero, when this web stems from the last pass of the allocator,
 172      and all info is still valid (i.e. it wasn't spilled).  */
 173   unsigned int old_web:1;
 174
 175   /* Used in rewrite_program2() to remember webs, which
 176      are already marked for (re)loading.  */
 177   unsigned int in_load:1;
 178
 179   /* If in_load is != 0, then this is nonzero, if only one use was seen
 180      since insertion in loadlist.  Zero if more uses currently need a
 181      reload.  Used to differentiate between inserting register loads or
 182      directly substituting the stackref.  */
 183   unsigned int one_load:1;
 184
 185   /* When using rewrite_program2() this flag gets set if some insns
 186      were inserted on behalf of this web.  IR spilling might ignore some
 187      deaths up to the def, so no code might be emitted and we need not to
 188      spill such a web again.  */
 189   unsigned int changed:1;
 190
 191   /* With interference region spilling it's sometimes the case, that a
 192      bb border is also an IR border for webs, which were targets of moves,
 193      which are already removed due to coalescing.  All webs, which are
 194      a destination of such a removed move, have this flag set.  */
 195   unsigned int target_of_spilled_move:1;
 196
 197   /* For optimistic coalescing we need to be able to break aliases, which
 198      includes restoring conflicts to those before coalescing.  This flag
 199      is set, if we have a list of conflicts before coalescing.  It's needed
 200      because that list is lazily constructed only when actually needed.  */
 201   unsigned int have_orig_conflicts:1;
 202
 203   /* Current state of the node.  */
 204   ENUM_BITFIELD(node_type) type:5;
 205
 206   /* A regclass, combined from preferred and alternate class, or calculated
 207      from usable_regs.  Used only for debugging, and to determine
 208      add_hardregs.  */
 209   ENUM_BITFIELD(reg_class) regclass:10;
 210
 211   /* Additional consecutive hardregs needed for this web.  */
 212   int add_hardregs;
 213
 214   /* Number of conflicts currently.  */
 215   int num_conflicts;
 216
 217   /* Numbers of uses and defs, which belong to this web.  */
 218   unsigned int num_uses;
 219   unsigned int num_defs;
 220
 221   /* The (reg:M a) or (subreg:M1 (reg:M2 a) x) rtx which this
 222      web is based on.  This is used to distinguish subreg webs
 223      from it's reg parents, and to get hold of the mode.  */
 224   rtx orig_x;
 225
 226   /* If this web is a subweb, this point to the super web.  Otherwise
 227      it's NULL.  */
 228   struct web *parent_web;
 229
 230   /* If this web is a subweb, but not the last one, this points to the
 231      next subweb of the same super web.  Otherwise it's NULL.  */
 232   struct web *subreg_next;
 233
 234   /* The set of webs (or subwebs), this web conflicts with.  */
 235   struct conflict_link *conflict_list;
 236
 237   /* If have_orig_conflicts is set this contains a copy of conflict_list,
 238      as it was right after building the interference graph.
 239      It's used for incremental i-graph building and for breaking
 240      coalescings again.  */
 241   struct conflict_link *orig_conflict_list;
 242
 243   /* Bitmap of all conflicts which don't count this pass, because of
 244      non-intersecting hardregs of the conflicting webs.  See also
 245      record_conflict().  */
 246   bitmap useless_conflicts;
 247
 248   /* Different sets of hard registers, for all usable registers, ...  */
 249   HARD_REG_SET usable_regs;
 250   /* ... the same before coalescing, ...  */
 251   HARD_REG_SET orig_usable_regs;
 252   /* ... colors of all already colored neighbors (used when biased coloring
 253      is active), and ...  */
 254   HARD_REG_SET bias_colors;
 255   /* ... colors of PRECOLORED webs this web is connected to by a move.  */
 256   HARD_REG_SET prefer_colors;
 257
 258   /* Number of usable colors in usable_regs.  */
 259   int num_freedom;
 260
 261   /* After successfull coloring the graph each web gets a new reg rtx,
 262      with which the original uses and defs are replaced.  This is it.  */
 263   rtx reg_rtx;
 264
 265   /* While spilling this is the rtx of the home of spilled webs.
 266      It can be a mem ref (a stack slot), or a pseudo register.  */
 267   rtx stack_slot;
 268
 269   /* Used in rewrite_program2() to remember the using
 270      insn last seen for webs needing (re)loads.  */
 271   rtx last_use_insn;
 272
 273   /* If this web is rematerializable, this contains the RTL pattern
 274      usable as source for that.  Otherwise it's NULL.  */
 275   rtx pattern;
 276
 277   /* All the defs and uses.  There are num_defs, resp.
 278      num_uses elements.  */
 279   struct ref **defs; /* [0..num_defs-1] */
 280   struct ref **uses; /* [0..num_uses-1] */
 281
 282   /* The web to which this web is aliased (coalesced).  If NULL, this
 283      web is not coalesced into some other (but might still be a target
 284      for other webs).  */
 285   struct web *alias;
 286
 287   /* With iterated coalescing this is a list of active moves this web
 288      is involved in.  */
 289   struct move_list *moves;
 290
 291   /* The list implementation.  */
 292   struct dlist *dlink;
 293
 294   /* While building webs, out of web-parts, this holds a (partial)
 295      list of all refs for this web seen so far.  */
 296   struct df_link *temp_refs;
 297 };
 298
 299 /* For implementing a single linked list.  */
 300 struct web_link
 301 {
 302   struct web_link *next;
 303   struct web *web;
 304 };
 305
 306 /* A subconflict is part of a conflict edge to track precisely,
 307    which parts of two webs conflict, in case not all of both webs do.  */
 308 struct sub_conflict
 309 {
 310   /* The next partial conflict.  For one such list the parent-web of
 311      all the S webs, resp. the parent of all the T webs are constant.  */
 312   struct sub_conflict *next;
 313   struct web *s;
 314   struct web *t;
 315 };
 316
 317 /* This represents an edge in the conflict graph.  */
 318 struct conflict_link
 319 {
 320   struct conflict_link *next;
 321
 322   /* The web we conflict with (the Target of the edge).  */
 323   struct web *t;
 324
 325   /* If not the complete source web and T conflict, this points to
 326      the list of parts which really conflict.  */
 327   struct sub_conflict *sub;
 328 };
 329
 330 /* For iterated coalescing the moves can be in these states.  */
 331 enum move_type
 332 {
 333   WORKLIST, MV_COALESCED, CONSTRAINED, FROZEN, ACTIVE,
 334   LAST_MOVE_TYPE
 335 };
 336
 337 /* Structure of a move we are considering coalescing.  */
 338 struct move
 339 {
 340   rtx insn;
 341   struct web *source_web;
 342   struct web *target_web;
 343   enum move_type type;
 344   struct dlist *dlink;
 345 };
 346
 347 /* List of moves.  */
 348 struct move_list
 349 {
 350   struct move_list *next;
 351   struct move *move;
 352 };
 353
 354 /* To have fast access to the defs and uses per insn, we have one such
 355    structure per insn.  The difference to the normal df.c structures is,
 356    that it doesn't contain any NULL refs, which df.c produces in case
 357    an insn was modified and it only contains refs to pseudo regs, or to
 358    hardregs which matter for allocation, i.e. those not in
 359    never_use_colors.  */
 360 struct ra_insn_info
 361 {
 362   unsigned int num_defs, num_uses;
 363   struct ref **defs, **uses;
 364 };
 365
 366 /* The above structures are stored in this array, indexed by UID...  */
 367 extern struct ra_insn_info *insn_df;
 368 /* ... and the size of that array, as we add insn after setting it up.  */
 369 extern int insn_df_max_uid;
 370
 371 /* The interference graph.  */
 372 extern sbitmap igraph;
 373 /* And how to access it.  I and J are web indices.  If the bit
 374    igraph_index(I, J) is set, then they conflict.  Note, that
 375    if only parts of webs conflict, then also only those parts
 376    are noted in the I-graph (i.e. the parent webs not).  */
 377 #define igraph_index(i, j) ((i) < (j) ? ((j)*((j)-1)/2)+(i) : ((i)*((i)-1)/2)+(j))
 378 /* This is the bitmap of all (even partly) conflicting super webs.
 379    If bit I*num_webs+J or J*num_webs+I is set, then I and J (both being
 380    super web indices) conflict, maybe only partially.  Note the
 381    assymetry.  */
 382 extern sbitmap sup_igraph;
 383
 384 /* After the first pass, and when interference region spilling is
 385    activated, bit I is set, when the insn with UID I contains some
 386    refs to pseudos which die at the insn.  */
 387 extern sbitmap insns_with_deaths;
 388 /* The size of that sbitmap.  */
 389 extern int death_insns_max_uid;
 390
 391 /* All the web-parts.  There are exactly as many web-parts as there
 392    are register refs in the insn stream.  */
 393 extern struct web_part *web_parts;
 394
 395 /* The number of all webs, including subwebs.  */
 396 extern unsigned int num_webs;
 397 /* The number of just the subwebs.  */
 398 extern unsigned int num_subwebs;
 399 /* The number of all webs, including subwebs.  */
 400 extern unsigned int num_allwebs;
 401
 402 /* For easy access when given a web ID: id2web[W->id] == W.  */
 403 extern struct web **id2web;
 404 /* For each hardreg, the web which represents it.  */
 405 extern struct web *hardreg2web[FIRST_PSEUDO_REGISTER];
 406
 407 /* Given the ID of a df_ref, which represent a DEF, def2web[ID] is
 408    the web, to which this def belongs.  */
 409 extern struct web **def2web;
 410 /* The same as def2web, just for uses.  */
 411 extern struct web **use2web;
 412
 413 /* The list of all recognized and coalescable move insns.  */
 414 extern struct move_list *wl_moves;
 415
 416
 417 /* Some parts of the compiler which we run after colorizing
 418    clean reg_renumber[], so we need another place for the colors.
 419    This is copied to reg_renumber[] just before returning to toplev.  */
 420 extern short *ra_reg_renumber;
 421 /* The size of that array.  Some passes after coloring might have created
 422    new pseudos, which will get no color.  */
 423 extern int ra_max_regno;
 424
 425 /* The dataflow structure of the current function, while regalloc
 426    runs.  */
 427 extern struct df *df;
 428
 429 /* For each basic block B we have a bitmap of DF_REF_ID's of uses,
 430    which backward reach the end of B.  */
 431 extern bitmap *live_at_end;
 432
 433 /* One pass is: collecting registers refs, buiding I-graph, spilling.
 434    And this is how often we already ran that for the current function.  */
 435 extern int ra_pass;
 436
 437 /* The maximum pseudo regno, just before register allocation starts.
 438    While regalloc runs all pseudos with a larger number represent
 439    potentially stack slots or hardregs.  I call them stackwebs or
 440    stackpseudos.  */
 441 extern unsigned int max_normal_pseudo;
 442
 443 /* One of the fixed colors.  It must be < FIRST_PSEUDO_REGISTER, because
 444    we sometimes want to check the color against a HARD_REG_SET.  It must
 445    be >= 0, because negative values mean "no color".
 446    This color is used for the above stackwebs, when they can't be colored.
 447    I.e. normally they would be spilled, but they already represent
 448    stackslots.  So they are colored with an invalid color.  It has
 449    the property that even webs which conflict can have that color at the
 450    same time.  I.e. a stackweb with that color really represents a
 451    stackslot.  */
 452 extern int an_unusable_color;
 453
 454 /* While building the I-graph, every time insn UID is looked at,
 455    number_seen[UID] is incremented.  For debugging.  */
 456 extern int *number_seen;
 457
 458 /* The different lists on which a web can be (based on the type).  */
 459 extern struct dlist *web_lists[(int) LAST_NODE_TYPE];
 460 #define WEBS(type) (web_lists[(int)(type)])
 461
 462 /* The largest DF_REF_ID of defs resp. uses, as it was in the
 463    last pass.  In the first pass this is zero.  Used to distinguish new
 464    from old refrences.  */
 465 extern unsigned int last_def_id;
 466 extern unsigned int last_use_id;
 467
 468 /* Similar for UIDs and number of webs.  */
 469 extern int last_max_uid;
 470 extern unsigned int last_num_webs;
 471
 472 /* If I is the ID of an old use, and last_check_uses[I] is set,
 473    then we must reevaluate it's flow while building the new I-graph.  */
 474 extern sbitmap last_check_uses;
 475
 476 /* If nonzero, record_conflict() saves the current conflict list of
 477    webs in orig_conflict_list, when not already done so, and the conflict
 478    list is going to be changed.  It is set, after initially building the
 479    I-graph.  I.e. new conflicts due to coalescing trigger that copying.  */
 480 extern unsigned int remember_conflicts;
 481
 482 /* The maximum UID right before calling regalloc().
 483    Used to detect any instructions inserted by the allocator.  */
 484 extern int orig_max_uid;
 485
 486 /* A HARD_REG_SET of those color, which can't be used for coalescing.
 487    Includes e.g. fixed_regs.  */
 488 extern HARD_REG_SET never_use_colors;
 489 /* For each class C this is reg_class_contents[C] \ never_use_colors.  */
 490 extern HARD_REG_SET usable_regs[N_REG_CLASSES];
 491 /* For each class C the count of hardregs in usable_regs[C].  */
 492 extern unsigned int num_free_regs[N_REG_CLASSES];
 493 /* For each mode M the hardregs, which are MODE_OK for M, and have
 494    enough space behind them to hold an M value.  Additinally
 495    if reg R is OK for mode M, but it needs two hardregs, then R+1 will
 496    also be set here, even if R+1 itself is not OK for M.  I.e. this
 497    represent the possible resources which could be taken away be a value
 498    in mode M.  */
 499 extern HARD_REG_SET hardregs_for_mode[NUM_MACHINE_MODES];
 500 /* For 0 <= I <= 255, the number of bits set in I.  Used to calculate
 501    the number of set bits in a HARD_REG_SET.  */
 502 extern unsigned char byte2bitcount[256];
 503
 504 /* Expressive helper macros.  */
 505 #define ID2WEB(I) id2web[I]
 506 #define NUM_REGS(W) (((W)->type == PRECOLORED) ? 1 : (W)->num_freedom)
 507 #define SUBWEB_P(W) (GET_CODE ((W)->orig_x) == SUBREG)
 508
 509 /* Constant usable as debug area to ra_debug_msg.  */
 510 #define DUMP_COSTS              0x0001
 511 #define DUMP_WEBS               0x0002
 512 #define DUMP_IGRAPH             0x0004
 513 #define DUMP_PROCESS            0x0008
 514 #define DUMP_COLORIZE           0x0010
 515 #define DUMP_ASM                0x0020
 516 #define DUMP_CONSTRAINTS        0x0040
 517 #define DUMP_RESULTS            0x0080
 518 #define DUMP_DF                 0x0100
 519 #define DUMP_RTL                0x0200
 520 #define DUMP_FINAL_RTL          0x0400
 521 #define DUMP_REGCLASS           0x0800
 522 #define DUMP_SM                 0x1000
 523 #define DUMP_LAST_FLOW          0x2000
 524 #define DUMP_LAST_RTL           0x4000
 525 #define DUMP_REBUILD            0x8000
 526 #define DUMP_IGRAPH_M           0x10000
 527 #define DUMP_VALIDIFY           0x20000
 528 #define DUMP_EVER               ((unsigned int)-1)
 529 #define DUMP_NEARLY_EVER        (DUMP_EVER - DUMP_COSTS - DUMP_IGRAPH_M)
 530
 531 /* All the wanted debug levels as ORing of the various DUMP_xxx
 532    constants.  */
 533 extern unsigned int debug_new_regalloc;
 534
 535 /* Nonzero means we want biased coloring.  */
 536 extern int flag_ra_biased;
 537
 538 /* Nonzero if we want to use improved (and slow) spilling.  This
 539    includes also interference region spilling (see below).  */
 540 extern int flag_ra_improved_spilling;
 541
 542 /* Nonzero for using interference region spilling.  Zero for improved
 543    Chaintin style spilling (only at deaths).  */
 544 extern int flag_ra_ir_spilling;
 545
 546 /* Nonzero if we use optimistic coalescing, zero for iterated
 547    coalescing.  */
 548 extern int flag_ra_optimistic_coalescing;
 549
 550 /* Nonzero if we want to break aliases of spilled webs.  Forced to
 551    nonzero, when flag_ra_optimistic_coalescing is.  */
 552 extern int flag_ra_break_aliases;
 553
 554 /* Nonzero if we want to merge the spill costs of webs which
 555    are coalesced.  */
 556 extern int flag_ra_merge_spill_costs;
 557
 558 /* Nonzero if we want to spill at every use, instead of at deaths,
 559    or intereference region borders.  */
 560 extern int flag_ra_spill_every_use;
 561
 562 /* Nonzero to output all notes in the debug dumps.  */
 563 extern int flag_ra_dump_notes;
 564
 565 extern inline void * ra_alloc PARAMS ((size_t));
 566 extern inline void * ra_calloc PARAMS ((size_t));
 567 extern int hard_regs_count PARAMS ((HARD_REG_SET));
 568 extern rtx ra_emit_move_insn PARAMS ((rtx, rtx));
 569 extern void ra_debug_msg PARAMS ((unsigned int,
 570                                   const char *, ...)) ATTRIBUTE_PRINTF_2;
 571 extern int hard_regs_intersect_p PARAMS ((HARD_REG_SET *, HARD_REG_SET *));
 572 extern unsigned int rtx_to_bits PARAMS ((rtx));
 573 extern struct web * find_subweb PARAMS ((struct web *, rtx));
 574 extern struct web * find_subweb_2 PARAMS ((struct web *, unsigned int));
 575 extern struct web * find_web_for_subweb_1 PARAMS ((struct web *));
 576
 577 #define find_web_for_subweb(w) (((w)->parent_web) \
 578                                 ? find_web_for_subweb_1 ((w)->parent_web) \
 579                                 : (w))
 580
 581 extern void ra_build_realloc PARAMS ((struct df *));
 582 extern void ra_build_free PARAMS ((void));
 583 extern void ra_build_free_all PARAMS ((struct df *));
 584 extern void ra_colorize_init PARAMS ((void));
 585 extern void ra_colorize_free_all PARAMS ((void));
 586 extern void ra_rewrite_init PARAMS ((void));
 587
 588 extern void ra_print_rtx PARAMS ((FILE *, rtx, int));
 589 extern void ra_print_rtx_top PARAMS ((FILE *, rtx, int));
 590 extern void ra_debug_rtx PARAMS ((rtx));
 591 extern void ra_debug_insns PARAMS ((rtx, int));
 592 extern void ra_debug_bbi PARAMS ((int));
 593 extern void ra_print_rtl_with_bb PARAMS ((FILE *, rtx));
 594 extern void dump_igraph PARAMS ((struct df *));
 595 extern void dump_igraph_machine PARAMS ((void));
 596 extern void dump_constraints PARAMS ((void));
 597 extern void dump_cost PARAMS ((unsigned int));
 598 extern void dump_graph_cost PARAMS ((unsigned int, const char *));
 599 extern void dump_ra PARAMS ((struct df *));
 600 extern void dump_number_seen PARAMS ((void));
 601 extern void dump_static_insn_cost PARAMS ((FILE *, const char *,
 602                                            const char *));
 603 extern void dump_web_conflicts PARAMS ((struct web *));
 604 extern void dump_web_insns PARAMS ((struct web*));
 605 extern int web_conflicts_p PARAMS ((struct web *, struct web *));
 606 extern void debug_hard_reg_set PARAMS ((HARD_REG_SET));
 607
 608 extern void remove_list PARAMS ((struct dlist *, struct dlist **));
 609 extern struct dlist * pop_list PARAMS ((struct dlist **));
 610 extern void record_conflict PARAMS ((struct web *, struct web *));
 611 extern int memref_is_stack_slot PARAMS ((rtx));
 612 extern void build_i_graph PARAMS ((struct df *));
 613 extern void put_web PARAMS ((struct web *, enum node_type));
 614 extern void remove_web_from_list PARAMS ((struct web *));
 615 extern void reset_lists PARAMS ((void));
 616 extern struct web * alias PARAMS ((struct web *));
 617 extern void merge_moves PARAMS ((struct web *, struct web *));
 618 extern void ra_colorize_graph PARAMS ((struct df *));
 619
 620 extern void actual_spill PARAMS ((void));
 621 extern void emit_colors PARAMS ((struct df *));
 622 extern void delete_moves PARAMS ((void));
 623 extern void setup_renumber PARAMS ((int));
 624 extern void remove_suspicious_death_notes PARAMS ((void));