gcc/flow.c

   1 /* Data flow analysis for GNU compiler.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 /* This file contains the data flow analysis pass of the compiler.  It
  23    computes data flow information which tells combine_instructions
  24    which insns to consider combining and controls register allocation.
  25
  26    Additional data flow information that is too bulky to record is
  27    generated during the analysis, and is used at that time to create
  28    autoincrement and autodecrement addressing.
  29
  30    The first step is dividing the function into basic blocks.
  31    find_basic_blocks does this.  Then life_analysis determines
  32    where each register is live and where it is dead.
  33
  34    ** find_basic_blocks **
  35
  36    find_basic_blocks divides the current function's rtl into basic
  37    blocks and constructs the CFG.  The blocks are recorded in the
  38    basic_block_info array; the CFG exists in the edge structures
  39    referenced by the blocks.
  40
  41    find_basic_blocks also finds any unreachable loops and deletes them.
  42
  43    ** life_analysis **
  44
  45    life_analysis is called immediately after find_basic_blocks.
  46    It uses the basic block information to determine where each
  47    hard or pseudo register is live.
  48
  49    ** live-register info **
  50
  51    The information about where each register is live is in two parts:
  52    the REG_NOTES of insns, and the vector basic_block->global_live_at_start.
  53
  54    basic_block->global_live_at_start has an element for each basic
  55    block, and the element is a bit-vector with a bit for each hard or
  56    pseudo register.  The bit is 1 if the register is live at the
  57    beginning of the basic block.
  58
  59    Two types of elements can be added to an insn's REG_NOTES.
  60    A REG_DEAD note is added to an insn's REG_NOTES for any register
  61    that meets both of two conditions:  The value in the register is not
  62    needed in subsequent insns and the insn does not replace the value in
  63    the register (in the case of multi-word hard registers, the value in
  64    each register must be replaced by the insn to avoid a REG_DEAD note).
  65
  66    In the vast majority of cases, an object in a REG_DEAD note will be
  67    used somewhere in the insn.  The (rare) exception to this is if an
  68    insn uses a multi-word hard register and only some of the registers are
  69    needed in subsequent insns.  In that case, REG_DEAD notes will be
  70    provided for those hard registers that are not subsequently needed.
  71    Partial REG_DEAD notes of this type do not occur when an insn sets
  72    only some of the hard registers used in such a multi-word operand;
  73    omitting REG_DEAD notes for objects stored in an insn is optional and
  74    the desire to do so does not justify the complexity of the partial
  75    REG_DEAD notes.
  76
  77    REG_UNUSED notes are added for each register that is set by the insn
  78    but is unused subsequently (if every register set by the insn is unused
  79    and the insn does not reference memory or have some other side-effect,
  80    the insn is deleted instead).  If only part of a multi-word hard
  81    register is used in a subsequent insn, REG_UNUSED notes are made for
  82    the parts that will not be used.
  83
  84    To determine which registers are live after any insn, one can
  85    start from the beginning of the basic block and scan insns, noting
  86    which registers are set by each insn and which die there.
  87
  88    ** Other actions of life_analysis **
  89
  90    life_analysis sets up the LOG_LINKS fields of insns because the
  91    information needed to do so is readily available.
  92
  93    life_analysis deletes insns whose only effect is to store a value
  94    that is never used.
  95
  96    life_analysis notices cases where a reference to a register as
  97    a memory address can be combined with a preceding or following
  98    incrementation or decrementation of the register.  The separate
  99    instruction to increment or decrement is deleted and the address
 100    is changed to a POST_INC or similar rtx.
 101
 102    Each time an incrementing or decrementing address is created,
 103    a REG_INC element is added to the insn's REG_NOTES list.
 104
 105    life_analysis fills in certain vectors containing information about
 106    register usage: REG_N_REFS, REG_N_DEATHS, REG_N_SETS, REG_LIVE_LENGTH,
 107    REG_N_CALLS_CROSSED and REG_BASIC_BLOCK.
 108
 109    life_analysis sets current_function_sp_is_unchanging if the function
 110    doesn't modify the stack pointer.  */
 111
 112 /* TODO:
 113
 114    Split out from life_analysis:
 115         - local property discovery (bb->local_live, bb->local_set)
 116         - global property computation
 117         - log links creation
 118         - pre/post modify transformation
 119 */
 120 \f
 121 #include "config.h"
 122 #include "system.h"
 123 #include "tree.h"
 124 #include "rtl.h"
 125 #include "tm_p.h"
 126 #include "hard-reg-set.h"
 127 #include "basic-block.h"
 128 #include "insn-config.h"
 129 #include "regs.h"
 130 #include "flags.h"
 131 #include "output.h"
 132 #include "function.h"
 133 #include "except.h"
 134 #include "toplev.h"
 135 #include "recog.h"
 136 #include "insn-flags.h"
 137 #include "expr.h"
 138 #include "ssa.h"
 139
 140 #include "obstack.h"
 141 #include "splay-tree.h"
 142
 143 #define obstack_chunk_alloc xmalloc
 144 #define obstack_chunk_free free
 145
 146 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
 147    the stack pointer does not matter.  The value is tested only in
 148    functions that have frame pointers.
 149    No definition is equivalent to always zero.  */
 150 #ifndef EXIT_IGNORE_STACK
 151 #define EXIT_IGNORE_STACK 0
 152 #endif
 153
 154 #ifndef HAVE_epilogue
 155 #define HAVE_epilogue 0
 156 #endif
 157 #ifndef HAVE_prologue
 158 #define HAVE_prologue 0
 159 #endif
 160 #ifndef HAVE_sibcall_epilogue
 161 #define HAVE_sibcall_epilogue 0
 162 #endif
 163
 164 #ifndef LOCAL_REGNO
 165 #define LOCAL_REGNO(REGNO)  0
 166 #endif
 167 #ifndef EPILOGUE_USES
 168 #define EPILOGUE_USES(REGNO)  0
 169 #endif
 170
 171 /* The contents of the current function definition are allocated
 172    in this obstack, and all are freed at the end of the function.
 173    For top-level functions, this is temporary_obstack.
 174    Separate obstacks are made for nested functions.  */
 175
 176 extern struct obstack *function_obstack;
 177
 178 /* Number of basic blocks in the current function.  */
 179
 180 int n_basic_blocks;
 181
 182 /* Number of edges in the current function.  */
 183
 184 int n_edges;
 185
 186 /* The basic block array.  */
 187
 188 varray_type basic_block_info;
 189
 190 /* The special entry and exit blocks.  */
 191
 192 struct basic_block_def entry_exit_blocks[2]
 193 = {{NULL,                       /* head */
 194     NULL,                       /* end */
 195     NULL,                       /* pred */
 196     NULL,                       /* succ */
 197     NULL,                       /* local_set */
 198     NULL,                       /* global_live_at_start */
 199     NULL,                       /* global_live_at_end */
 200     NULL,                       /* aux */
 201     ENTRY_BLOCK,                /* index */
 202     0,                          /* loop_depth */
 203     -1, -1,                     /* eh_beg, eh_end */
 204     0                           /* count */
 205   },
 206   {
 207     NULL,                       /* head */
 208     NULL,                       /* end */
 209     NULL,                       /* pred */
 210     NULL,                       /* succ */
 211     NULL,                       /* local_set */
 212     NULL,                       /* global_live_at_start */
 213     NULL,                       /* global_live_at_end */
 214     NULL,                       /* aux */
 215     EXIT_BLOCK,                 /* index */
 216     0,                          /* loop_depth */
 217     -1, -1,                     /* eh_beg, eh_end */
 218     0                           /* count */
 219   }
 220 };
 221
 222 /* Nonzero if the second flow pass has completed.  */
 223 int flow2_completed;
 224
 225 /* Maximum register number used in this function, plus one.  */
 226
 227 int max_regno;
 228
 229 /* Indexed by n, giving various register information */
 230
 231 varray_type reg_n_info;
 232
 233 /* Size of a regset for the current function,
 234    in (1) bytes and (2) elements.  */
 235
 236 int regset_bytes;
 237 int regset_size;
 238
 239 /* Regset of regs live when calls to `setjmp'-like functions happen.  */
 240 /* ??? Does this exist only for the setjmp-clobbered warning message?  */
 241
 242 regset regs_live_at_setjmp;
 243
 244 /* List made of EXPR_LIST rtx's which gives pairs of pseudo registers
 245    that have to go in the same hard reg.
 246    The first two regs in the list are a pair, and the next two
 247    are another pair, etc.  */
 248 rtx regs_may_share;
 249
 250 /* Set of registers that may be eliminable.  These are handled specially
 251    in updating regs_ever_live.  */
 252
 253 static HARD_REG_SET elim_reg_set;
 254
 255 /* The basic block structure for every insn, indexed by uid.  */
 256
 257 varray_type basic_block_for_insn;
 258
 259 /* The labels mentioned in non-jump rtl.  Valid during find_basic_blocks.  */
 260 /* ??? Should probably be using LABEL_NUSES instead.  It would take a
 261    bit of surgery to be able to use or co-opt the routines in jump.  */
 262
 263 static rtx label_value_list;
 264 static rtx tail_recursion_label_list;
 265
 266 /* Holds information for tracking conditional register life information.  */
 267 struct reg_cond_life_info
 268 {
 269   /* An EXPR_LIST of conditions under which a register is dead.  */
 270   rtx condition;
 271
 272   /* ??? Could store mask of bytes that are dead, so that we could finally
 273      track lifetimes of multi-word registers accessed via subregs.  */
 274 };
 275
 276 /* For use in communicating between propagate_block and its subroutines.
 277    Holds all information needed to compute life and def-use information.  */
 278
 279 struct propagate_block_info
 280 {
 281   /* The basic block we're considering.  */
 282   basic_block bb;
 283
 284   /* Bit N is set if register N is conditionally or unconditionally live.  */
 285   regset reg_live;
 286
 287   /* Bit N is set if register N is set this insn.  */
 288   regset new_set;
 289
 290   /* Element N is the next insn that uses (hard or pseudo) register N
 291      within the current basic block; or zero, if there is no such insn.  */
 292   rtx *reg_next_use;
 293
 294   /* Contains a list of all the MEMs we are tracking for dead store
 295      elimination.  */
 296   rtx mem_set_list;
 297
 298   /* If non-null, record the set of registers set in the basic block.  */
 299   regset local_set;
 300
 301 #ifdef HAVE_conditional_execution
 302   /* Indexed by register number, holds a reg_cond_life_info for each
 303      register that is not unconditionally live or dead.  */
 304   splay_tree reg_cond_dead;
 305
 306   /* Bit N is set if register N is in an expression in reg_cond_dead.  */
 307   regset reg_cond_reg;
 308 #endif
 309
 310   /* Non-zero if the value of CC0 is live.  */
 311   int cc0_live;
 312
 313   /* Flags controling the set of information propagate_block collects.  */
 314   int flags;
 315 };
 316
 317 /* Store the data structures necessary for depth-first search.  */
 318 struct depth_first_search_dsS {
 319   /* stack for backtracking during the algorithm */
 320   basic_block *stack;
 321
 322   /* number of edges in the stack.  That is, positions 0, ..., sp-1
 323      have edges.  */
 324   unsigned int sp;
 325
 326   /* record of basic blocks already seen by depth-first search */
 327   sbitmap visited_blocks;
 328 };
 329 typedef struct depth_first_search_dsS *depth_first_search_ds;
 330
 331 /* Forward declarations */
 332 static int count_basic_blocks           PARAMS ((rtx));
 333 static void find_basic_blocks_1         PARAMS ((rtx));
 334 static rtx find_label_refs              PARAMS ((rtx, rtx));
 335 static void clear_edges                 PARAMS ((void));
 336 static void make_edges                  PARAMS ((rtx));
 337 static void make_label_edge             PARAMS ((sbitmap *, basic_block,
 338                                                  rtx, int));
 339 static void make_eh_edge                PARAMS ((sbitmap *, eh_nesting_info *,
 340                                                  basic_block, rtx, int));
 341 static void mark_critical_edges         PARAMS ((void));
 342 static void move_stray_eh_region_notes  PARAMS ((void));
 343 static void record_active_eh_regions    PARAMS ((rtx));
 344
 345 static void commit_one_edge_insertion   PARAMS ((edge));
 346
 347 static void delete_unreachable_blocks   PARAMS ((void));
 348 static void delete_eh_regions           PARAMS ((void));
 349 static int can_delete_note_p            PARAMS ((rtx));
 350 static void expunge_block               PARAMS ((basic_block));
 351 static int can_delete_label_p           PARAMS ((rtx));
 352 static int tail_recursion_label_p       PARAMS ((rtx));
 353 static int merge_blocks_move_predecessor_nojumps PARAMS ((basic_block,
 354                                                           basic_block));
 355 static int merge_blocks_move_successor_nojumps PARAMS ((basic_block,
 356                                                         basic_block));
 357 static int merge_blocks                 PARAMS ((edge,basic_block,basic_block));
 358 static void try_merge_blocks            PARAMS ((void));
 359 static void tidy_fallthru_edges         PARAMS ((void));
 360 static int verify_wide_reg_1            PARAMS ((rtx *, void *));
 361 static void verify_wide_reg             PARAMS ((int, rtx, rtx));
 362 static void verify_local_live_at_start  PARAMS ((regset, basic_block));
 363 static int set_noop_p                   PARAMS ((rtx));
 364 static int noop_move_p                  PARAMS ((rtx));
 365 static void delete_noop_moves           PARAMS ((rtx));
 366 static void notice_stack_pointer_modification_1 PARAMS ((rtx, rtx, void *));
 367 static void notice_stack_pointer_modification PARAMS ((rtx));
 368 static void mark_reg                    PARAMS ((rtx, void *));
 369 static void mark_regs_live_at_end       PARAMS ((regset));
 370 static int set_phi_alternative_reg      PARAMS ((rtx, int, int, void *));
 371 static void calculate_global_regs_live  PARAMS ((sbitmap, sbitmap, int));
 372 static void propagate_block_delete_insn PARAMS ((basic_block, rtx));
 373 static rtx propagate_block_delete_libcall PARAMS ((basic_block, rtx, rtx));
 374 static int insn_dead_p                  PARAMS ((struct propagate_block_info *,
 375                                                  rtx, int, rtx));
 376 static int libcall_dead_p               PARAMS ((struct propagate_block_info *,
 377                                                  rtx, rtx));
 378 static void mark_set_regs               PARAMS ((struct propagate_block_info *,
 379                                                  rtx, rtx));
 380 static void mark_set_1                  PARAMS ((struct propagate_block_info *,
 381                                                  enum rtx_code, rtx, rtx,
 382                                                  rtx, int));
 383 #ifdef HAVE_conditional_execution
 384 static int mark_regno_cond_dead         PARAMS ((struct propagate_block_info *,
 385                                                  int, rtx));
 386 static void free_reg_cond_life_info     PARAMS ((splay_tree_value));
 387 static int flush_reg_cond_reg_1         PARAMS ((splay_tree_node, void *));
 388 static void flush_reg_cond_reg          PARAMS ((struct propagate_block_info *,
 389                                                  int));
 390 static rtx ior_reg_cond                 PARAMS ((rtx, rtx));
 391 static rtx not_reg_cond                 PARAMS ((rtx));
 392 static rtx nand_reg_cond                PARAMS ((rtx, rtx));
 393 #endif
 394 #ifdef AUTO_INC_DEC
 395 static void attempt_auto_inc            PARAMS ((struct propagate_block_info *,
 396                                                  rtx, rtx, rtx, rtx, rtx));
 397 static void find_auto_inc               PARAMS ((struct propagate_block_info *,
 398                                                  rtx, rtx));
 399 static int try_pre_increment_1          PARAMS ((struct propagate_block_info *,
 400                                                  rtx));
 401 static int try_pre_increment            PARAMS ((rtx, rtx, HOST_WIDE_INT));
 402 #endif
 403 static void mark_used_reg               PARAMS ((struct propagate_block_info *,
 404                                                  rtx, rtx, rtx));
 405 static void mark_used_regs              PARAMS ((struct propagate_block_info *,
 406                                                  rtx, rtx, rtx));
 407 void dump_flow_info                     PARAMS ((FILE *));
 408 void debug_flow_info                    PARAMS ((void));
 409 static void dump_edge_info              PARAMS ((FILE *, edge, int));
 410
 411 static void invalidate_mems_from_autoinc PARAMS ((struct propagate_block_info *,
 412                                                   rtx));
 413 static void remove_fake_successors      PARAMS ((basic_block));
 414 static void flow_nodes_print            PARAMS ((const char *, const sbitmap,
 415                                                  FILE *));
 416 static void flow_edge_list_print        PARAMS ((const char *, const edge *,
 417                                                  int, FILE *));
 418 static void flow_loops_cfg_dump         PARAMS ((const struct loops *,
 419                                                  FILE *));
 420 static int flow_loop_nested_p           PARAMS ((struct loop *,
 421                                                  struct loop *));
 422 static int flow_loop_entry_edges_find   PARAMS ((basic_block, const sbitmap,
 423                                                  edge **));
 424 static int flow_loop_exit_edges_find    PARAMS ((const sbitmap, edge **));
 425 static int flow_loop_nodes_find PARAMS ((basic_block, basic_block, sbitmap));
 426 static int flow_depth_first_order_compute PARAMS ((int *, int *));
 427 static void flow_dfs_compute_reverse_init
 428   PARAMS ((depth_first_search_ds));
 429 static void flow_dfs_compute_reverse_add_bb
 430   PARAMS ((depth_first_search_ds, basic_block));
 431 static basic_block flow_dfs_compute_reverse_execute
 432   PARAMS ((depth_first_search_ds));
 433 static void flow_dfs_compute_reverse_finish
 434   PARAMS ((depth_first_search_ds));
 435 static basic_block flow_loop_pre_header_find PARAMS ((basic_block, const sbitmap *));
 436 static void flow_loop_tree_node_add     PARAMS ((struct loop *, struct loop *));
 437 static void flow_loops_tree_build       PARAMS ((struct loops *));
 438 static int flow_loop_level_compute      PARAMS ((struct loop *, int));
 439 static int flow_loops_level_compute     PARAMS ((struct loops *));
 440 \f
 441 /* Find basic blocks of the current function.
 442    F is the first insn of the function and NREGS the number of register
 443    numbers in use.  */
 444
 445 void
 446 find_basic_blocks (f, nregs, file)
 447      rtx f;
 448      int nregs ATTRIBUTE_UNUSED;
 449      FILE *file ATTRIBUTE_UNUSED;
 450 {
 451   int max_uid;
 452
 453   /* Flush out existing data.  */
 454   if (basic_block_info != NULL)
 455     {
 456       int i;
 457
 458       clear_edges ();
 459
 460       /* Clear bb->aux on all extant basic blocks.  We'll use this as a
 461          tag for reuse during create_basic_block, just in case some pass
 462          copies around basic block notes improperly.  */
 463       for (i = 0; i < n_basic_blocks; ++i)
 464         BASIC_BLOCK (i)->aux = NULL;
 465
 466       VARRAY_FREE (basic_block_info);
 467     }
 468
 469   n_basic_blocks = count_basic_blocks (f);
 470
 471   /* Size the basic block table.  The actual structures will be allocated
 472      by find_basic_blocks_1, since we want to keep the structure pointers
 473      stable across calls to find_basic_blocks.  */
 474   /* ??? This whole issue would be much simpler if we called find_basic_blocks
 475      exactly once, and thereafter we don't have a single long chain of
 476      instructions at all until close to the end of compilation when we
 477      actually lay them out.  */
 478
 479   VARRAY_BB_INIT (basic_block_info, n_basic_blocks, "basic_block_info");
 480
 481   find_basic_blocks_1 (f);
 482
 483   /* Record the block to which an insn belongs.  */
 484   /* ??? This should be done another way, by which (perhaps) a label is
 485      tagged directly with the basic block that it starts.  It is used for
 486      more than that currently, but IMO that is the only valid use.  */
 487
 488   max_uid = get_max_uid ();
 489 #ifdef AUTO_INC_DEC
 490   /* Leave space for insns life_analysis makes in some cases for auto-inc.
 491      These cases are rare, so we don't need too much space.  */
 492   max_uid += max_uid / 10;
 493 #endif
 494
 495   compute_bb_for_insn (max_uid);
 496
 497   /* Discover the edges of our cfg.  */
 498   record_active_eh_regions (f);
 499   make_edges (label_value_list);
 500
 501   /* Do very simple cleanup now, for the benefit of code that runs between
 502      here and cleanup_cfg, e.g. thread_prologue_and_epilogue_insns.  */
 503   tidy_fallthru_edges ();
 504
 505   mark_critical_edges ();
 506
 507 #ifdef ENABLE_CHECKING
 508   verify_flow_info ();
 509 #endif
 510 }
 511
 512 /* Count the basic blocks of the function.  */
 513
 514 static int
 515 count_basic_blocks (f)
 516      rtx f;
 517 {
 518   register rtx insn;
 519   register RTX_CODE prev_code;
 520   register int count = 0;
 521   int eh_region = 0;
 522   int call_had_abnormal_edge = 0;
 523
 524   prev_code = JUMP_INSN;
 525   for (insn = f; insn; insn = NEXT_INSN (insn))
 526     {
 527       register RTX_CODE code = GET_CODE (insn);
 528
 529       if (code == CODE_LABEL
 530           || (GET_RTX_CLASS (code) == 'i'
 531               && (prev_code == JUMP_INSN
 532                   || prev_code == BARRIER
 533                   || (prev_code == CALL_INSN && call_had_abnormal_edge))))
 534         count++;
 535
 536       /* Record whether this call created an edge.  */
 537       if (code == CALL_INSN)
 538         {
 539           rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
 540           int region = (note ? INTVAL (XEXP (note, 0)) : 1);
 541
 542           call_had_abnormal_edge = 0;
 543
 544           /* If there is an EH region or rethrow, we have an edge.  */
 545           if ((eh_region && region > 0)
 546               || find_reg_note (insn, REG_EH_RETHROW, NULL_RTX))
 547             call_had_abnormal_edge = 1;
 548           else if (nonlocal_goto_handler_labels && region >= 0)
 549             /* If there is a nonlocal goto label and the specified
 550                region number isn't -1, we have an edge. (0 means
 551                no throw, but might have a nonlocal goto).  */
 552             call_had_abnormal_edge = 1;
 553         }
 554
 555       if (code != NOTE)
 556         prev_code = code;
 557       else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
 558         ++eh_region;
 559       else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END)
 560         --eh_region;
 561     }
 562
 563   /* The rest of the compiler works a bit smoother when we don't have to
 564      check for the edge case of do-nothing functions with no basic blocks.  */
 565   if (count == 0)
 566     {
 567       emit_insn (gen_rtx_USE (VOIDmode, const0_rtx));
 568       count = 1;
 569     }
 570
 571   return count;
 572 }
 573
 574 /* Scan a list of insns for labels referred to other than by jumps.
 575    This is used to scan the alternatives of a call placeholder.  */
 576 static rtx
 577 find_label_refs (f, lvl)
 578      rtx f;
 579      rtx lvl;
 580 {
 581   rtx insn;
 582
 583   for (insn = f; insn; insn = NEXT_INSN (insn))
 584     if (INSN_P (insn))
 585       {
 586         rtx note;
 587
 588         /* Make a list of all labels referred to other than by jumps
 589            (which just don't have the REG_LABEL notes).
 590
 591            Make a special exception for labels followed by an ADDR*VEC,
 592            as this would be a part of the tablejump setup code.
 593
 594            Make a special exception for the eh_return_stub_label, which
 595            we know isn't part of any otherwise visible control flow.  */
 596
 597         for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
 598           if (REG_NOTE_KIND (note) == REG_LABEL)
 599             {
 600               rtx lab = XEXP (note, 0), next;
 601
 602               if (lab == eh_return_stub_label)
 603                 ;
 604               else if ((next = next_nonnote_insn (lab)) != NULL
 605                        && GET_CODE (next) == JUMP_INSN
 606                        && (GET_CODE (PATTERN (next)) == ADDR_VEC
 607                            || GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC))
 608                 ;
 609               else if (GET_CODE (lab) == NOTE)
 610                 ;
 611               else
 612                 lvl = alloc_EXPR_LIST (0, XEXP (note, 0), lvl);
 613             }
 614       }
 615
 616   return lvl;
 617 }
 618
 619 /* Find all basic blocks of the function whose first insn is F.
 620
 621    Collect and return a list of labels whose addresses are taken.  This
 622    will be used in make_edges for use with computed gotos.  */
 623
 624 static void
 625 find_basic_blocks_1 (f)
 626      rtx f;
 627 {
 628   register rtx insn, next;
 629   int i = 0;
 630   rtx bb_note = NULL_RTX;
 631   rtx eh_list = NULL_RTX;
 632   rtx lvl = NULL_RTX;
 633   rtx trll = NULL_RTX;
 634   rtx head = NULL_RTX;
 635   rtx end = NULL_RTX;
 636
 637   /* We process the instructions in a slightly different way than we did
 638      previously.  This is so that we see a NOTE_BASIC_BLOCK after we have
 639      closed out the previous block, so that it gets attached at the proper
 640      place.  Since this form should be equivalent to the previous,
 641      count_basic_blocks continues to use the old form as a check.  */
 642
 643   for (insn = f; insn; insn = next)
 644     {
 645       enum rtx_code code = GET_CODE (insn);
 646
 647       next = NEXT_INSN (insn);
 648
 649       switch (code)
 650         {
 651         case NOTE:
 652           {
 653             int kind = NOTE_LINE_NUMBER (insn);
 654
 655             /* Keep a LIFO list of the currently active exception notes.  */
 656             if (kind == NOTE_INSN_EH_REGION_BEG)
 657               eh_list = alloc_INSN_LIST (insn, eh_list);
 658             else if (kind == NOTE_INSN_EH_REGION_END)
 659               {
 660                 rtx t = eh_list;
 661
 662                 eh_list = XEXP (eh_list, 1);
 663                 free_INSN_LIST_node (t);
 664               }
 665
 666             /* Look for basic block notes with which to keep the
 667                basic_block_info pointers stable.  Unthread the note now;
 668                we'll put it back at the right place in create_basic_block.
 669                Or not at all if we've already found a note in this block.  */
 670             else if (kind == NOTE_INSN_BASIC_BLOCK)
 671               {
 672                 if (bb_note == NULL_RTX)
 673                   bb_note = insn;
 674                 else
 675                   next = flow_delete_insn (insn);
 676               }
 677             break;
 678           }
 679
 680         case CODE_LABEL:
 681           /* A basic block starts at a label.  If we've closed one off due
 682              to a barrier or some such, no need to do it again.  */
 683           if (head != NULL_RTX)
 684             {
 685               /* While we now have edge lists with which other portions of
 686                  the compiler might determine a call ending a basic block
 687                  does not imply an abnormal edge, it will be a bit before
 688                  everything can be updated.  So continue to emit a noop at
 689                  the end of such a block.  */
 690               if (GET_CODE (end) == CALL_INSN && ! SIBLING_CALL_P (end))
 691                 {
 692                   rtx nop = gen_rtx_USE (VOIDmode, const0_rtx);
 693                   end = emit_insn_after (nop, end);
 694                 }
 695
 696               create_basic_block (i++, head, end, bb_note);
 697               bb_note = NULL_RTX;
 698             }
 699
 700           head = end = insn;
 701           break;
 702
 703         case JUMP_INSN:
 704           /* A basic block ends at a jump.  */
 705           if (head == NULL_RTX)
 706             head = insn;
 707           else
 708             {
 709               /* ??? Make a special check for table jumps.  The way this
 710                  happens is truly and amazingly gross.  We are about to
 711                  create a basic block that contains just a code label and
 712                  an addr*vec jump insn.  Worse, an addr_diff_vec creates
 713                  its own natural loop.
 714
 715                  Prevent this bit of brain damage, pasting things together
 716                  correctly in make_edges.
 717
 718                  The correct solution involves emitting the table directly
 719                  on the tablejump instruction as a note, or JUMP_LABEL.  */
 720
 721               if (GET_CODE (PATTERN (insn)) == ADDR_VEC
 722                   || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
 723                 {
 724                   head = end = NULL;
 725                   n_basic_blocks--;
 726                   break;
 727                 }
 728             }
 729           end = insn;
 730           goto new_bb_inclusive;
 731
 732         case BARRIER:
 733           /* A basic block ends at a barrier.  It may be that an unconditional
 734              jump already closed the basic block -- no need to do it again.  */
 735           if (head == NULL_RTX)
 736             break;
 737
 738           /* While we now have edge lists with which other portions of the
 739              compiler might determine a call ending a basic block does not
 740              imply an abnormal edge, it will be a bit before everything can
 741              be updated.  So continue to emit a noop at the end of such a
 742              block.  */
 743           if (GET_CODE (end) == CALL_INSN && ! SIBLING_CALL_P (end))
 744             {
 745               rtx nop = gen_rtx_USE (VOIDmode, const0_rtx);
 746               end = emit_insn_after (nop, end);
 747             }
 748           goto new_bb_exclusive;
 749
 750         case CALL_INSN:
 751           {
 752             /* Record whether this call created an edge.  */
 753             rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
 754             int region = (note ? INTVAL (XEXP (note, 0)) : 1);
 755             int call_has_abnormal_edge = 0;
 756
 757             if (GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
 758               {
 759                 /* Scan each of the alternatives for label refs.  */
 760                 lvl = find_label_refs (XEXP (PATTERN (insn), 0), lvl);
 761                 lvl = find_label_refs (XEXP (PATTERN (insn), 1), lvl);
 762                 lvl = find_label_refs (XEXP (PATTERN (insn), 2), lvl);
 763                 /* Record its tail recursion label, if any.  */
 764                 if (XEXP (PATTERN (insn), 3) != NULL_RTX)
 765                   trll = alloc_EXPR_LIST (0, XEXP (PATTERN (insn), 3), trll);
 766               }
 767
 768             /* If there is an EH region or rethrow, we have an edge.  */
 769             if ((eh_list && region > 0)
 770                 || find_reg_note (insn, REG_EH_RETHROW, NULL_RTX))
 771               call_has_abnormal_edge = 1;
 772             else if (nonlocal_goto_handler_labels && region >= 0)
 773               /* If there is a nonlocal goto label and the specified
 774                  region number isn't -1, we have an edge. (0 means
 775                  no throw, but might have a nonlocal goto).  */
 776               call_has_abnormal_edge = 1;
 777
 778             /* A basic block ends at a call that can either throw or
 779                do a non-local goto.  */
 780             if (call_has_abnormal_edge)
 781               {
 782               new_bb_inclusive:
 783                 if (head == NULL_RTX)
 784                   head = insn;
 785                 end = insn;
 786
 787               new_bb_exclusive:
 788                 create_basic_block (i++, head, end, bb_note);
 789                 head = end = NULL_RTX;
 790                 bb_note = NULL_RTX;
 791                 break;
 792               }
 793           }
 794           /* Fall through.  */
 795
 796         default:
 797           if (GET_RTX_CLASS (code) == 'i')
 798             {
 799               if (head == NULL_RTX)
 800                 head = insn;
 801               end = insn;
 802             }
 803           break;
 804         }
 805
 806       if (GET_RTX_CLASS (code) == 'i')
 807         {
 808           rtx note;
 809
 810           /* Make a list of all labels referred to other than by jumps
 811              (which just don't have the REG_LABEL notes).
 812
 813              Make a special exception for labels followed by an ADDR*VEC,
 814              as this would be a part of the tablejump setup code.
 815
 816              Make a special exception for the eh_return_stub_label, which
 817              we know isn't part of any otherwise visible control flow.  */
 818
 819           for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
 820             if (REG_NOTE_KIND (note) == REG_LABEL)
 821               {
 822                 rtx lab = XEXP (note, 0), next;
 823
 824                 if (lab == eh_return_stub_label)
 825                   ;
 826                 else if ((next = next_nonnote_insn (lab)) != NULL
 827                          && GET_CODE (next) == JUMP_INSN
 828                          && (GET_CODE (PATTERN (next)) == ADDR_VEC
 829                              || GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC))
 830                   ;
 831                 else if (GET_CODE (lab) == NOTE)
 832                   ;
 833                 else
 834                   lvl = alloc_EXPR_LIST (0, XEXP (note, 0), lvl);
 835               }
 836         }
 837     }
 838
 839   if (head != NULL_RTX)
 840     create_basic_block (i++, head, end, bb_note);
 841   else if (bb_note)
 842     flow_delete_insn (bb_note);
 843
 844   if (i != n_basic_blocks)
 845     abort ();
 846
 847   label_value_list = lvl;
 848   tail_recursion_label_list = trll;
 849 }
 850
 851 /* Tidy the CFG by deleting unreachable code and whatnot.  */
 852
 853 void
 854 cleanup_cfg (f)
 855      rtx f;
 856 {
 857   delete_unreachable_blocks ();
 858   move_stray_eh_region_notes ();
 859   record_active_eh_regions (f);
 860   try_merge_blocks ();
 861   mark_critical_edges ();
 862
 863   /* Kill the data we won't maintain.  */
 864   free_EXPR_LIST_list (&label_value_list);
 865   free_EXPR_LIST_list (&tail_recursion_label_list);
 866 }
 867
 868 /* Create a new basic block consisting of the instructions between
 869    HEAD and END inclusive.  Reuses the note and basic block struct
 870    in BB_NOTE, if any.  */
 871
 872 void
 873 create_basic_block (index, head, end, bb_note)
 874      int index;
 875      rtx head, end, bb_note;
 876 {
 877   basic_block bb;
 878
 879   if (bb_note
 880       && ! RTX_INTEGRATED_P (bb_note)
 881       && (bb = NOTE_BASIC_BLOCK (bb_note)) != NULL
 882       && bb->aux == NULL)
 883     {
 884       /* If we found an existing note, thread it back onto the chain.  */
 885
 886       rtx after;
 887
 888       if (GET_CODE (head) == CODE_LABEL)
 889         after = head;
 890       else
 891         {
 892           after = PREV_INSN (head);
 893           head = bb_note;
 894         }
 895
 896       if (after != bb_note && NEXT_INSN (after) != bb_note)
 897         reorder_insns (bb_note, bb_note, after);
 898     }
 899   else
 900     {
 901       /* Otherwise we must create a note and a basic block structure.
 902          Since we allow basic block structs in rtl, give the struct
 903          the same lifetime by allocating it off the function obstack
 904          rather than using malloc.  */
 905
 906       bb = (basic_block) obstack_alloc (function_obstack, sizeof (*bb));
 907       memset (bb, 0, sizeof (*bb));
 908
 909       if (GET_CODE (head) == CODE_LABEL)
 910         bb_note = emit_note_after (NOTE_INSN_BASIC_BLOCK, head);
 911       else
 912         {
 913           bb_note = emit_note_before (NOTE_INSN_BASIC_BLOCK, head);
 914           head = bb_note;
 915         }
 916       NOTE_BASIC_BLOCK (bb_note) = bb;
 917     }
 918
 919   /* Always include the bb note in the block.  */
 920   if (NEXT_INSN (end) == bb_note)
 921     end = bb_note;
 922
 923   bb->head = head;
 924   bb->end = end;
 925   bb->index = index;
 926   BASIC_BLOCK (index) = bb;
 927
 928   /* Tag the block so that we know it has been used when considering
 929      other basic block notes.  */
 930   bb->aux = bb;
 931 }
 932 \f
 933 /* Records the basic block struct in BB_FOR_INSN, for every instruction
 934    indexed by INSN_UID.  MAX is the size of the array.  */
 935
 936 void
 937 compute_bb_for_insn (max)
 938      int max;
 939 {
 940   int i;
 941
 942   if (basic_block_for_insn)
 943     VARRAY_FREE (basic_block_for_insn);
 944   VARRAY_BB_INIT (basic_block_for_insn, max, "basic_block_for_insn");
 945
 946   for (i = 0; i < n_basic_blocks; ++i)
 947     {
 948       basic_block bb = BASIC_BLOCK (i);
 949       rtx insn, end;
 950
 951       end = bb->end;
 952       insn = bb->head;
 953       while (1)
 954         {
 955           int uid = INSN_UID (insn);
 956           if (uid < max)
 957             VARRAY_BB (basic_block_for_insn, uid) = bb;
 958           if (insn == end)
 959             break;
 960           insn = NEXT_INSN (insn);
 961         }
 962     }
 963 }
 964
 965 /* Free the memory associated with the edge structures.  */
 966
 967 static void
 968 clear_edges ()
 969 {
 970   int i;
 971   edge n, e;
 972
 973   for (i = 0; i < n_basic_blocks; ++i)
 974     {
 975       basic_block bb = BASIC_BLOCK (i);
 976
 977       for (e = bb->succ; e; e = n)
 978         {
 979           n = e->succ_next;
 980           free (e);
 981         }
 982
 983       bb->succ = 0;
 984       bb->pred = 0;
 985     }
 986
 987   for (e = ENTRY_BLOCK_PTR->succ; e; e = n)
 988     {
 989       n = e->succ_next;
 990       free (e);
 991     }
 992
 993   ENTRY_BLOCK_PTR->succ = 0;
 994   EXIT_BLOCK_PTR->pred = 0;
 995
 996   n_edges = 0;
 997 }
 998
 999 /* Identify the edges between basic blocks.
1000
1001    NONLOCAL_LABEL_LIST is a list of non-local labels in the function.  Blocks
1002    that are otherwise unreachable may be reachable with a non-local goto.
1003
1004    BB_EH_END is an array indexed by basic block number in which we record
1005    the list of exception regions active at the end of the basic block.  */
1006
1007 static void
1008 make_edges (label_value_list)
1009      rtx label_value_list;
1010 {
1011   int i;
1012   eh_nesting_info *eh_nest_info = init_eh_nesting_info ();
1013   sbitmap *edge_cache = NULL;
1014
1015   /* Assume no computed jump; revise as we create edges.  */
1016   current_function_has_computed_jump = 0;
1017
1018   /* Heavy use of computed goto in machine-generated code can lead to
1019      nearly fully-connected CFGs.  In that case we spend a significant
1020      amount of time searching the edge lists for duplicates.  */
1021   if (forced_labels || label_value_list)
1022     {
1023       edge_cache = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
1024       sbitmap_vector_zero (edge_cache, n_basic_blocks);
1025     }
1026
1027   /* By nature of the way these get numbered, block 0 is always the entry.  */
1028   make_edge (edge_cache, ENTRY_BLOCK_PTR, BASIC_BLOCK (0), EDGE_FALLTHRU);
1029
1030   for (i = 0; i < n_basic_blocks; ++i)
1031     {
1032       basic_block bb = BASIC_BLOCK (i);
1033       rtx insn, x;
1034       enum rtx_code code;
1035       int force_fallthru = 0;
1036
1037       /* Examine the last instruction of the block, and discover the
1038          ways we can leave the block.  */
1039
1040       insn = bb->end;
1041       code = GET_CODE (insn);
1042
1043       /* A branch.  */
1044       if (code == JUMP_INSN)
1045         {
1046           rtx tmp;
1047
1048           /* ??? Recognize a tablejump and do the right thing.  */
1049           if ((tmp = JUMP_LABEL (insn)) != NULL_RTX
1050               && (tmp = NEXT_INSN (tmp)) != NULL_RTX
1051               && GET_CODE (tmp) == JUMP_INSN
1052               && (GET_CODE (PATTERN (tmp)) == ADDR_VEC
1053                   || GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC))
1054             {
1055               rtvec vec;
1056               int j;
1057
1058               if (GET_CODE (PATTERN (tmp)) == ADDR_VEC)
1059                 vec = XVEC (PATTERN (tmp), 0);
1060               else
1061                 vec = XVEC (PATTERN (tmp), 1);
1062
1063               for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j)
1064                 make_label_edge (edge_cache, bb,
1065                                  XEXP (RTVEC_ELT (vec, j), 0), 0);
1066
1067               /* Some targets (eg, ARM) emit a conditional jump that also
1068                  contains the out-of-range target.  Scan for these and
1069                  add an edge if necessary.  */
1070               if ((tmp = single_set (insn)) != NULL
1071                   && SET_DEST (tmp) == pc_rtx
1072                   && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
1073                   && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF)
1074                 make_label_edge (edge_cache, bb,
1075                                  XEXP (XEXP (SET_SRC (tmp), 2), 0), 0);
1076
1077 #ifdef CASE_DROPS_THROUGH
1078               /* Silly VAXen.  The ADDR_VEC is going to be in the way of
1079                  us naturally detecting fallthru into the next block.  */
1080               force_fallthru = 1;
1081 #endif
1082             }
1083
1084           /* If this is a computed jump, then mark it as reaching
1085              everything on the label_value_list and forced_labels list.  */
1086           else if (computed_jump_p (insn))
1087             {
1088               current_function_has_computed_jump = 1;
1089
1090               for (x = label_value_list; x; x = XEXP (x, 1))
1091                 make_label_edge (edge_cache, bb, XEXP (x, 0), EDGE_ABNORMAL);
1092
1093               for (x = forced_labels; x; x = XEXP (x, 1))
1094                 make_label_edge (edge_cache, bb, XEXP (x, 0), EDGE_ABNORMAL);
1095             }
1096
1097           /* Returns create an exit out.  */
1098           else if (returnjump_p (insn))
1099             make_edge (edge_cache, bb, EXIT_BLOCK_PTR, 0);
1100
1101           /* Otherwise, we have a plain conditional or unconditional jump.  */
1102           else
1103             {
1104               if (! JUMP_LABEL (insn))
1105                 abort ();
1106               make_label_edge (edge_cache, bb, JUMP_LABEL (insn), 0);
1107             }
1108         }
1109
1110       /* If this is a sibling call insn, then this is in effect a
1111          combined call and return, and so we need an edge to the
1112          exit block.  No need to worry about EH edges, since we
1113          wouldn't have created the sibling call in the first place.  */
1114
1115       if (code == CALL_INSN && SIBLING_CALL_P (insn))
1116         make_edge (edge_cache, bb, EXIT_BLOCK_PTR,
1117                    EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
1118       else
1119
1120       /* If this is a CALL_INSN, then mark it as reaching the active EH
1121          handler for this CALL_INSN.  If we're handling asynchronous
1122          exceptions then any insn can reach any of the active handlers.
1123
1124          Also mark the CALL_INSN as reaching any nonlocal goto handler.  */
1125
1126       if (code == CALL_INSN || asynchronous_exceptions)
1127         {
1128           /* Add any appropriate EH edges.  We do this unconditionally
1129              since there may be a REG_EH_REGION or REG_EH_RETHROW note
1130              on the call, and this needn't be within an EH region.  */
1131           make_eh_edge (edge_cache, eh_nest_info, bb, insn, bb->eh_end);
1132
1133           /* If we have asynchronous exceptions, do the same for *all*
1134              exception regions active in the block.  */
1135           if (asynchronous_exceptions
1136               && bb->eh_beg != bb->eh_end)
1137             {
1138               if (bb->eh_beg >= 0)
1139                 make_eh_edge (edge_cache, eh_nest_info, bb,
1140                               NULL_RTX, bb->eh_beg);
1141
1142               for (x = bb->head; x != bb->end; x = NEXT_INSN (x))
1143                 if (GET_CODE (x) == NOTE
1144                     && (NOTE_LINE_NUMBER (x) == NOTE_INSN_EH_REGION_BEG
1145                         || NOTE_LINE_NUMBER (x) == NOTE_INSN_EH_REGION_END))
1146                   {
1147                     int region = NOTE_EH_HANDLER (x);
1148                     make_eh_edge (edge_cache, eh_nest_info, bb,
1149                                   NULL_RTX, region);
1150                   }
1151             }
1152
1153           if (code == CALL_INSN && nonlocal_goto_handler_labels)
1154             {
1155               /* ??? This could be made smarter: in some cases it's possible
1156                  to tell that certain calls will not do a nonlocal goto.
1157
1158                  For example, if the nested functions that do the nonlocal
1159                  gotos do not have their addresses taken, then only calls to
1160                  those functions or to other nested functions that use them
1161                  could possibly do nonlocal gotos.  */
1162               /* We do know that a REG_EH_REGION note with a value less
1163                  than 0 is guaranteed not to perform a non-local goto.  */
1164               rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1165               if (!note || INTVAL (XEXP (note, 0)) >=  0)
1166                 for (x = nonlocal_goto_handler_labels; x; x = XEXP (x, 1))
1167                   make_label_edge (edge_cache, bb, XEXP (x, 0),
1168                                    EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
1169             }
1170         }
1171
1172       /* We know something about the structure of the function __throw in
1173          libgcc2.c.  It is the only function that ever contains eh_stub
1174          labels.  It modifies its return address so that the last block
1175          returns to one of the eh_stub labels within it.  So we have to
1176          make additional edges in the flow graph.  */
1177       if (i + 1 == n_basic_blocks && eh_return_stub_label != 0)
1178         make_label_edge (edge_cache, bb, eh_return_stub_label, EDGE_EH);
1179
1180       /* Find out if we can drop through to the next block.  */
1181       insn = next_nonnote_insn (insn);
1182       if (!insn || (i + 1 == n_basic_blocks && force_fallthru))
1183         make_edge (edge_cache, bb, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
1184       else if (i + 1 < n_basic_blocks)
1185         {
1186           rtx tmp = BLOCK_HEAD (i + 1);
1187           if (GET_CODE (tmp) == NOTE)
1188             tmp = next_nonnote_insn (tmp);
1189           if (force_fallthru || insn == tmp)
1190             make_edge (edge_cache, bb, BASIC_BLOCK (i + 1), EDGE_FALLTHRU);
1191         }
1192     }
1193
1194   free_eh_nesting_info (eh_nest_info);
1195   if (edge_cache)
1196     sbitmap_vector_free (edge_cache);
1197 }
1198
1199 /* Create an edge between two basic blocks.  FLAGS are auxiliary information
1200    about the edge that is accumulated between calls.  */
1201
1202 void
1203 make_edge (edge_cache, src, dst, flags)
1204      sbitmap *edge_cache;
1205      basic_block src, dst;
1206      int flags;
1207 {
1208   int use_edge_cache;
1209   edge e;
1210
1211   /* Don't bother with edge cache for ENTRY or EXIT; there aren't that
1212      many edges to them, and we didn't allocate memory for it.  */
1213   use_edge_cache = (edge_cache
1214                     && src != ENTRY_BLOCK_PTR
1215                     && dst != EXIT_BLOCK_PTR);
1216
1217   /* Make sure we don't add duplicate edges.  */
1218   if (! use_edge_cache || TEST_BIT (edge_cache[src->index], dst->index))
1219     for (e = src->succ; e; e = e->succ_next)
1220       if (e->dest == dst)
1221         {
1222           e->flags |= flags;
1223           return;
1224         }
1225
1226   e = (edge) xcalloc (1, sizeof (*e));
1227   n_edges++;
1228
1229   e->succ_next = src->succ;
1230   e->pred_next = dst->pred;
1231   e->src = src;
1232   e->dest = dst;
1233   e->flags = flags;
1234
1235   src->succ = e;
1236   dst->pred = e;
1237
1238   if (use_edge_cache)
1239     SET_BIT (edge_cache[src->index], dst->index);
1240 }
1241
1242 /* Create an edge from a basic block to a label.  */
1243
1244 static void
1245 make_label_edge (edge_cache, src, label, flags)
1246      sbitmap *edge_cache;
1247      basic_block src;
1248      rtx label;
1249      int flags;
1250 {
1251   if (GET_CODE (label) != CODE_LABEL)
1252     abort ();
1253
1254   /* If the label was never emitted, this insn is junk, but avoid a
1255      crash trying to refer to BLOCK_FOR_INSN (label).  This can happen
1256      as a result of a syntax error and a diagnostic has already been
1257      printed.  */
1258
1259   if (INSN_UID (label) == 0)
1260     return;
1261
1262   make_edge (edge_cache, src, BLOCK_FOR_INSN (label), flags);
1263 }
1264
1265 /* Create the edges generated by INSN in REGION.  */
1266
1267 static void
1268 make_eh_edge (edge_cache, eh_nest_info, src, insn, region)
1269      sbitmap *edge_cache;
1270      eh_nesting_info *eh_nest_info;
1271      basic_block src;
1272      rtx insn;
1273      int region;
1274 {
1275   handler_info **handler_list;
1276   int num, is_call;
1277
1278   is_call = (insn && GET_CODE (insn) == CALL_INSN ? EDGE_ABNORMAL_CALL : 0);
1279   num = reachable_handlers (region, eh_nest_info, insn, &handler_list);
1280   while (--num >= 0)
1281     {
1282       make_label_edge (edge_cache, src, handler_list[num]->handler_label,
1283                        EDGE_ABNORMAL | EDGE_EH | is_call);
1284     }
1285 }
1286
1287 /* EH_REGION notes appearing between basic blocks is ambiguous, and even
1288    dangerous if we intend to move basic blocks around.  Move such notes
1289    into the following block.  */
1290
1291 static void
1292 move_stray_eh_region_notes ()
1293 {
1294   int i;
1295   basic_block b1, b2;
1296
1297   if (n_basic_blocks < 2)
1298     return;
1299
1300   b2 = BASIC_BLOCK (n_basic_blocks - 1);
1301   for (i = n_basic_blocks - 2; i >= 0; --i, b2 = b1)
1302     {
1303       rtx insn, next, list = NULL_RTX;
1304
1305       b1 = BASIC_BLOCK (i);
1306       for (insn = NEXT_INSN (b1->end); insn != b2->head; insn = next)
1307         {
1308           next = NEXT_INSN (insn);
1309           if (GET_CODE (insn) == NOTE
1310               && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
1311                   || NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
1312             {
1313               /* Unlink from the insn chain.  */
1314               NEXT_INSN (PREV_INSN (insn)) = next;
1315               PREV_INSN (next) = PREV_INSN (insn);
1316
1317               /* Queue it.  */
1318               NEXT_INSN (insn) = list;
1319               list = insn;
1320             }
1321         }
1322
1323       if (list == NULL_RTX)
1324         continue;
1325
1326       /* Find where to insert these things.  */
1327       insn = b2->head;
1328       if (GET_CODE (insn) == CODE_LABEL)
1329         insn = NEXT_INSN (insn);
1330
1331       while (list)
1332         {
1333           next = NEXT_INSN (list);
1334           add_insn_after (list, insn);
1335           list = next;
1336         }
1337     }
1338 }
1339
1340 /* Recompute eh_beg/eh_end for each basic block.  */
1341
1342 static void
1343 record_active_eh_regions (f)
1344      rtx f;
1345 {
1346   rtx insn, eh_list = NULL_RTX;
1347   int i = 0;
1348   basic_block bb = BASIC_BLOCK (0);
1349
1350   for (insn = f; insn; insn = NEXT_INSN (insn))
1351     {
1352       if (bb->head == insn)
1353         bb->eh_beg = (eh_list ? NOTE_EH_HANDLER (XEXP (eh_list, 0)) : -1);
1354
1355       if (GET_CODE (insn) == NOTE)
1356         {
1357           int kind = NOTE_LINE_NUMBER (insn);
1358           if (kind == NOTE_INSN_EH_REGION_BEG)
1359             eh_list = alloc_INSN_LIST (insn, eh_list);
1360           else if (kind == NOTE_INSN_EH_REGION_END)
1361             {
1362               rtx t = XEXP (eh_list, 1);
1363               free_INSN_LIST_node (eh_list);
1364               eh_list = t;
1365             }
1366         }
1367
1368       if (bb->end == insn)
1369         {
1370           bb->eh_end = (eh_list ? NOTE_EH_HANDLER (XEXP (eh_list, 0)) : -1);
1371           i += 1;
1372           if (i == n_basic_blocks)
1373             break;
1374           bb = BASIC_BLOCK (i);
1375         }
1376     }
1377 }
1378
1379 /* Identify critical edges and set the bits appropriately.  */
1380
1381 static void
1382 mark_critical_edges ()
1383 {
1384   int i, n = n_basic_blocks;
1385   basic_block bb;
1386
1387   /* We begin with the entry block.  This is not terribly important now,
1388      but could be if a front end (Fortran) implemented alternate entry
1389      points.  */
1390   bb = ENTRY_BLOCK_PTR;
1391   i = -1;
1392
1393   while (1)
1394     {
1395       edge e;
1396
1397       /* (1) Critical edges must have a source with multiple successors.  */
1398       if (bb->succ && bb->succ->succ_next)
1399         {
1400           for (e = bb->succ; e; e = e->succ_next)
1401             {
1402               /* (2) Critical edges must have a destination with multiple
1403                  predecessors.  Note that we know there is at least one
1404                  predecessor -- the edge we followed to get here.  */
1405               if (e->dest->pred->pred_next)
1406                 e->flags |= EDGE_CRITICAL;
1407               else
1408                 e->flags &= ~EDGE_CRITICAL;
1409             }
1410         }
1411       else
1412         {
1413           for (e = bb->succ; e; e = e->succ_next)
1414             e->flags &= ~EDGE_CRITICAL;
1415         }
1416
1417       if (++i >= n)
1418         break;
1419       bb = BASIC_BLOCK (i);
1420     }
1421 }
1422 \f
1423 /* Split a (typically critical) edge.  Return the new block.
1424    Abort on abnormal edges.
1425
1426    ??? The code generally expects to be called on critical edges.
1427    The case of a block ending in an unconditional jump to a
1428    block with multiple predecessors is not handled optimally.  */
1429
1430 basic_block
1431 split_edge (edge_in)
1432      edge edge_in;
1433 {
1434   basic_block old_pred, bb, old_succ;
1435   edge edge_out;
1436   rtx bb_note;
1437   int i, j;
1438
1439   /* Abnormal edges cannot be split.  */
1440   if ((edge_in->flags & EDGE_ABNORMAL) != 0)
1441     abort ();
1442
1443   old_pred = edge_in->src;
1444   old_succ = edge_in->dest;
1445
1446   /* Remove the existing edge from the destination's pred list.  */
1447   {
1448     edge *pp;
1449     for (pp = &old_succ->pred; *pp != edge_in; pp = &(*pp)->pred_next)
1450       continue;
1451     *pp = edge_in->pred_next;
1452     edge_in->pred_next = NULL;
1453   }
1454
1455   /* Create the new structures.  */
1456   bb = (basic_block) obstack_alloc (function_obstack, sizeof (*bb));
1457   edge_out = (edge) xcalloc (1, sizeof (*edge_out));
1458   n_edges++;
1459
1460   memset (bb, 0, sizeof (*bb));
1461
1462   /* ??? This info is likely going to be out of date very soon.  */
1463   if (old_succ->global_live_at_start)
1464     {
1465       bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (function_obstack);
1466       bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (function_obstack);
1467       COPY_REG_SET (bb->global_live_at_start, old_succ->global_live_at_start);
1468       COPY_REG_SET (bb->global_live_at_end, old_succ->global_live_at_start);
1469     }
1470
1471   /* Wire them up.  */
1472   bb->pred = edge_in;
1473   bb->succ = edge_out;
1474   bb->count = edge_in->count;
1475
1476   edge_in->dest = bb;
1477   edge_in->flags &= ~EDGE_CRITICAL;
1478
1479   edge_out->pred_next = old_succ->pred;
1480   edge_out->succ_next = NULL;
1481   edge_out->src = bb;
1482   edge_out->dest = old_succ;
1483   edge_out->flags = EDGE_FALLTHRU;
1484   edge_out->probability = REG_BR_PROB_BASE;
1485   edge_out->count = edge_in->count;
1486
1487   old_succ->pred = edge_out;
1488
1489   /* Tricky case -- if there existed a fallthru into the successor
1490      (and we're not it) we must add a new unconditional jump around
1491      the new block we're actually interested in.
1492
1493      Further, if that edge is critical, this means a second new basic
1494      block must be created to hold it.  In order to simplify correct
1495      insn placement, do this before we touch the existing basic block
1496      ordering for the block we were really wanting.  */
1497   if ((edge_in->flags & EDGE_FALLTHRU) == 0)
1498     {
1499       edge e;
1500       for (e = edge_out->pred_next; e; e = e->pred_next)
1501         if (e->flags & EDGE_FALLTHRU)
1502           break;
1503
1504       if (e)
1505         {
1506           basic_block jump_block;
1507           rtx pos;
1508
1509           if ((e->flags & EDGE_CRITICAL) == 0
1510               && e->src != ENTRY_BLOCK_PTR)
1511             {
1512               /* Non critical -- we can simply add a jump to the end
1513                  of the existing predecessor.  */
1514               jump_block = e->src;
1515             }
1516           else
1517             {
1518               /* We need a new block to hold the jump.  The simplest
1519                  way to do the bulk of the work here is to recursively
1520                  call ourselves.  */
1521               jump_block = split_edge (e);
1522               e = jump_block->succ;
1523             }
1524
1525           /* Now add the jump insn ...  */
1526           pos = emit_jump_insn_after (gen_jump (old_succ->head),
1527                                       jump_block->end);
1528           jump_block->end = pos;
1529           if (basic_block_for_insn)
1530             set_block_for_insn (pos, jump_block);
1531           emit_barrier_after (pos);
1532
1533           /* ... let jump know that label is in use, ...  */
1534           JUMP_LABEL (pos) = old_succ->head;
1535           ++LABEL_NUSES (old_succ->head);
1536
1537           /* ... and clear fallthru on the outgoing edge.  */
1538           e->flags &= ~EDGE_FALLTHRU;
1539
1540           /* Continue splitting the interesting edge.  */
1541         }
1542     }
1543
1544   /* Place the new block just in front of the successor.  */
1545   VARRAY_GROW (basic_block_info, ++n_basic_blocks);
1546   if (old_succ == EXIT_BLOCK_PTR)
1547     j = n_basic_blocks - 1;
1548   else
1549     j = old_succ->index;
1550   for (i = n_basic_blocks - 1; i > j; --i)
1551     {
1552       basic_block tmp = BASIC_BLOCK (i - 1);
1553       BASIC_BLOCK (i) = tmp;
1554       tmp->index = i;
1555     }
1556   BASIC_BLOCK (i) = bb;
1557   bb->index = i;
1558
1559   /* Create the basic block note.
1560
1561      Where we place the note can have a noticable impact on the generated
1562      code.  Consider this cfg:
1563
1564                         E
1565                         |
1566                         0
1567                        / \
1568                    +->1-->2--->E
1569                    |  |
1570                    +--+
1571
1572       If we need to insert an insn on the edge from block 0 to block 1,
1573       we want to ensure the instructions we insert are outside of any
1574       loop notes that physically sit between block 0 and block 1.  Otherwise
1575       we confuse the loop optimizer into thinking the loop is a phony.  */
1576   if (old_succ != EXIT_BLOCK_PTR
1577       && PREV_INSN (old_succ->head)
1578       && GET_CODE (PREV_INSN (old_succ->head)) == NOTE
1579       && NOTE_LINE_NUMBER (PREV_INSN (old_succ->head)) == NOTE_INSN_LOOP_BEG)
1580     bb_note = emit_note_before (NOTE_INSN_BASIC_BLOCK,
1581                                 PREV_INSN (old_succ->head));
1582   else if (old_succ != EXIT_BLOCK_PTR)
1583     bb_note = emit_note_before (NOTE_INSN_BASIC_BLOCK, old_succ->head);
1584   else
1585     bb_note = emit_note_after (NOTE_INSN_BASIC_BLOCK, get_last_insn ());
1586   NOTE_BASIC_BLOCK (bb_note) = bb;
1587   bb->head = bb->end = bb_note;
1588
1589   /* Not quite simple -- for non-fallthru edges, we must adjust the
1590      predecessor's jump instruction to target our new block.  */
1591   if ((edge_in->flags & EDGE_FALLTHRU) == 0)
1592     {
1593       rtx tmp, insn = old_pred->end;
1594       rtx old_label = old_succ->head;
1595       rtx new_label = gen_label_rtx ();
1596
1597       if (GET_CODE (insn) != JUMP_INSN)
1598         abort ();
1599
1600       /* ??? Recognize a tablejump and adjust all matching cases.  */
1601       if ((tmp = JUMP_LABEL (insn)) != NULL_RTX
1602           && (tmp = NEXT_INSN (tmp)) != NULL_RTX
1603           && GET_CODE (tmp) == JUMP_INSN
1604           && (GET_CODE (PATTERN (tmp)) == ADDR_VEC
1605               || GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC))
1606         {
1607           rtvec vec;
1608           int j;
1609
1610           if (GET_CODE (PATTERN (tmp)) == ADDR_VEC)
1611             vec = XVEC (PATTERN (tmp), 0);
1612           else
1613             vec = XVEC (PATTERN (tmp), 1);
1614
1615           for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j)
1616             if (XEXP (RTVEC_ELT (vec, j), 0) == old_label)
1617               {
1618                 RTVEC_ELT (vec, j) = gen_rtx_LABEL_REF (VOIDmode, new_label);
1619                 --LABEL_NUSES (old_label);
1620                 ++LABEL_NUSES (new_label);
1621               }
1622
1623           /* Handle casesi dispatch insns */
1624           if ((tmp = single_set (insn)) != NULL
1625               && SET_DEST (tmp) == pc_rtx
1626               && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
1627               && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF
1628               && XEXP (XEXP (SET_SRC (tmp), 2), 0) == old_label)
1629             {
1630               XEXP (SET_SRC (tmp), 2) = gen_rtx_LABEL_REF (VOIDmode,
1631                                                            new_label);
1632               --LABEL_NUSES (old_label);
1633               ++LABEL_NUSES (new_label);
1634             }
1635         }
1636       else
1637         {
1638           /* This would have indicated an abnormal edge.  */
1639           if (computed_jump_p (insn))
1640             abort ();
1641
1642           /* A return instruction can't be redirected.  */
1643           if (returnjump_p (insn))
1644             abort ();
1645
1646           /* If the insn doesn't go where we think, we're confused.  */
1647           if (JUMP_LABEL (insn) != old_label)
1648             abort ();
1649
1650           redirect_jump (insn, new_label, 0);
1651         }
1652
1653       emit_label_before (new_label, bb_note);
1654       bb->head = new_label;
1655     }
1656
1657   return bb;
1658 }
1659
1660 /* Queue instructions for insertion on an edge between two basic blocks.
1661    The new instructions and basic blocks (if any) will not appear in the
1662    CFG until commit_edge_insertions is called.  */
1663
1664 void
1665 insert_insn_on_edge (pattern, e)
1666      rtx pattern;
1667      edge e;
1668 {
1669   /* We cannot insert instructions on an abnormal critical edge.
1670      It will be easier to find the culprit if we die now.  */
1671   if ((e->flags & (EDGE_ABNORMAL|EDGE_CRITICAL))
1672       == (EDGE_ABNORMAL|EDGE_CRITICAL))
1673     abort ();
1674
1675   if (e->insns == NULL_RTX)
1676     start_sequence ();
1677   else
1678     push_to_sequence (e->insns);
1679
1680   emit_insn (pattern);
1681
1682   e->insns = get_insns ();
1683   end_sequence ();
1684 }
1685
1686 /* Update the CFG for the instructions queued on edge E.  */
1687
1688 static void
1689 commit_one_edge_insertion (e)
1690      edge e;
1691 {
1692   rtx before = NULL_RTX, after = NULL_RTX, insns, tmp, last;
1693   basic_block bb;
1694
1695   /* Pull the insns off the edge now since the edge might go away.  */
1696   insns = e->insns;
1697   e->insns = NULL_RTX;
1698
1699   /* Figure out where to put these things.  If the destination has
1700      one predecessor, insert there.  Except for the exit block.  */
1701   if (e->dest->pred->pred_next == NULL
1702       && e->dest != EXIT_BLOCK_PTR)
1703     {
1704       bb = e->dest;
1705
1706       /* Get the location correct wrt a code label, and "nice" wrt
1707          a basic block note, and before everything else.  */
1708       tmp = bb->head;
1709       if (GET_CODE (tmp) == CODE_LABEL)
1710         tmp = NEXT_INSN (tmp);
1711       if (NOTE_INSN_BASIC_BLOCK_P (tmp))
1712         tmp = NEXT_INSN (tmp);
1713       if (tmp == bb->head)
1714         before = tmp;
1715       else
1716         after = PREV_INSN (tmp);
1717     }
1718
1719   /* If the source has one successor and the edge is not abnormal,
1720      insert there.  Except for the entry block.  */
1721   else if ((e->flags & EDGE_ABNORMAL) == 0
1722            && e->src->succ->succ_next == NULL
1723            && e->src != ENTRY_BLOCK_PTR)
1724     {
1725       bb = e->src;
1726       /* It is possible to have a non-simple jump here.  Consider a target
1727          where some forms of unconditional jumps clobber a register.  This
1728          happens on the fr30 for example.
1729
1730          We know this block has a single successor, so we can just emit
1731          the queued insns before the jump.  */
1732       if (GET_CODE (bb->end) == JUMP_INSN)
1733         {
1734           before = bb->end;
1735         }
1736       else
1737         {
1738           /* We'd better be fallthru, or we've lost track of what's what.  */
1739           if ((e->flags & EDGE_FALLTHRU) == 0)
1740             abort ();
1741
1742           after = bb->end;
1743         }
1744     }
1745
1746   /* Otherwise we must split the edge.  */
1747   else
1748     {
1749       bb = split_edge (e);
1750       after = bb->end;
1751     }
1752
1753   /* Now that we've found the spot, do the insertion.  */
1754
1755   /* Set the new block number for these insns, if structure is allocated.  */
1756   if (basic_block_for_insn)
1757     {
1758       rtx i;
1759       for (i = insns; i != NULL_RTX; i = NEXT_INSN (i))
1760         set_block_for_insn (i, bb);
1761     }
1762
1763   if (before)
1764     {
1765       emit_insns_before (insns, before);
1766       if (before == bb->head)
1767         bb->head = insns;
1768
1769       last = prev_nonnote_insn (before);
1770     }
1771   else
1772     {
1773       last = emit_insns_after (insns, after);
1774       if (after == bb->end)
1775         bb->end = last;
1776     }
1777
1778   if (returnjump_p (last))
1779     {
1780       /* ??? Remove all outgoing edges from BB and add one for EXIT.
1781          This is not currently a problem because this only happens
1782          for the (single) epilogue, which already has a fallthru edge
1783          to EXIT.  */
1784
1785       e = bb->succ;
1786       if (e->dest != EXIT_BLOCK_PTR
1787           || e->succ_next != NULL
1788           || (e->flags & EDGE_FALLTHRU) == 0)
1789         abort ();
1790       e->flags &= ~EDGE_FALLTHRU;
1791
1792       emit_barrier_after (last);
1793       bb->end = last;
1794
1795       if (before)
1796         flow_delete_insn (before);
1797     }
1798   else if (GET_CODE (last) == JUMP_INSN)
1799     abort ();
1800 }
1801
1802 /* Update the CFG for all queued instructions.  */
1803
1804 void
1805 commit_edge_insertions ()
1806 {
1807   int i;
1808   basic_block bb;
1809
1810 #ifdef ENABLE_CHECKING
1811   verify_flow_info ();
1812 #endif
1813
1814   i = -1;
1815   bb = ENTRY_BLOCK_PTR;
1816   while (1)
1817     {
1818       edge e, next;
1819
1820       for (e = bb->succ; e; e = next)
1821         {
1822           next = e->succ_next;
1823           if (e->insns)
1824             commit_one_edge_insertion (e);
1825         }
1826
1827       if (++i >= n_basic_blocks)
1828         break;
1829       bb = BASIC_BLOCK (i);
1830     }
1831 }
1832 \f
1833 /* Delete all unreachable basic blocks.   */
1834
1835 static void
1836 delete_unreachable_blocks ()
1837 {
1838   basic_block *worklist, *tos;
1839   int deleted_handler;
1840   edge e;
1841   int i, n;
1842
1843   n = n_basic_blocks;
1844   tos = worklist = (basic_block *) xmalloc (sizeof (basic_block) * n);
1845
1846   /* Use basic_block->aux as a marker.  Clear them all.  */
1847
1848   for (i = 0; i < n; ++i)
1849     BASIC_BLOCK (i)->aux = NULL;
1850
1851   /* Add our starting points to the worklist.  Almost always there will
1852      be only one.  It isn't inconcievable that we might one day directly
1853      support Fortran alternate entry points.  */
1854
1855   for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
1856     {
1857       *tos++ = e->dest;
1858
1859       /* Mark the block with a handy non-null value.  */
1860       e->dest->aux = e;
1861     }
1862
1863   /* Iterate: find everything reachable from what we've already seen.  */
1864
1865   while (tos != worklist)
1866     {
1867       basic_block b = *--tos;
1868
1869       for (e = b->succ; e; e = e->succ_next)
1870         if (!e->dest->aux)
1871           {
1872             *tos++ = e->dest;
1873             e->dest->aux = e;
1874           }
1875     }
1876
1877   /* Delete all unreachable basic blocks.  Count down so that we don't
1878      interfere with the block renumbering that happens in flow_delete_block.  */
1879
1880   deleted_handler = 0;
1881
1882   for (i = n - 1; i >= 0; --i)
1883     {
1884       basic_block b = BASIC_BLOCK (i);
1885
1886       if (b->aux != NULL)
1887         /* This block was found.  Tidy up the mark.  */
1888         b->aux = NULL;
1889       else
1890         deleted_handler |= flow_delete_block (b);
1891     }
1892
1893   tidy_fallthru_edges ();
1894
1895   /* If we deleted an exception handler, we may have EH region begin/end
1896      blocks to remove as well.  */
1897   if (deleted_handler)
1898     delete_eh_regions ();
1899
1900   free (worklist);
1901 }
1902
1903 /* Find EH regions for which there is no longer a handler, and delete them.  */
1904
1905 static void
1906 delete_eh_regions ()
1907 {
1908   rtx insn;
1909
1910   update_rethrow_references ();
1911
1912   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1913     if (GET_CODE (insn) == NOTE)
1914       {
1915         if ((NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
1916             || (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END))
1917           {
1918             int num = NOTE_EH_HANDLER (insn);
1919             /* A NULL handler indicates a region is no longer needed,
1920                as long as its rethrow label isn't used.  */
1921             if (get_first_handler (num) == NULL && ! rethrow_used (num))
1922               {
1923                 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1924                 NOTE_SOURCE_FILE (insn) = 0;
1925               }
1926           }
1927       }
1928 }
1929
1930 /* Return true if NOTE is not one of the ones that must be kept paired,
1931    so that we may simply delete them.  */
1932
1933 static int
1934 can_delete_note_p (note)
1935      rtx note;
1936 {
1937   return (NOTE_LINE_NUMBER (note) == NOTE_INSN_DELETED
1938           || NOTE_LINE_NUMBER (note) == NOTE_INSN_BASIC_BLOCK);
1939 }
1940
1941 /* Unlink a chain of insns between START and FINISH, leaving notes
1942    that must be paired.  */
1943
1944 void
1945 flow_delete_insn_chain (start, finish)
1946      rtx start, finish;
1947 {
1948   /* Unchain the insns one by one.  It would be quicker to delete all
1949      of these with a single unchaining, rather than one at a time, but
1950      we need to keep the NOTE's.  */
1951
1952   rtx next;
1953
1954   while (1)
1955     {
1956       next = NEXT_INSN (start);
1957       if (GET_CODE (start) == NOTE && !can_delete_note_p (start))
1958         ;
1959       else if (GET_CODE (start) == CODE_LABEL
1960                && ! can_delete_label_p (start))
1961         {
1962           const char *name = LABEL_NAME (start);
1963           PUT_CODE (start, NOTE);
1964           NOTE_LINE_NUMBER (start) = NOTE_INSN_DELETED_LABEL;
1965           NOTE_SOURCE_FILE (start) = name;
1966         }
1967       else
1968         next = flow_delete_insn (start);
1969
1970       if (start == finish)
1971         break;
1972       start = next;
1973     }
1974 }
1975
1976 /* Delete the insns in a (non-live) block.  We physically delete every
1977    non-deleted-note insn, and update the flow graph appropriately.
1978
1979    Return nonzero if we deleted an exception handler.  */
1980
1981 /* ??? Preserving all such notes strikes me as wrong.  It would be nice
1982    to post-process the stream to remove empty blocks, loops, ranges, etc.  */
1983
1984 int
1985 flow_delete_block (b)
1986      basic_block b;
1987 {
1988   int deleted_handler = 0;
1989   rtx insn, end, tmp;
1990
1991   /* If the head of this block is a CODE_LABEL, then it might be the
1992      label for an exception handler which can't be reached.
1993
1994      We need to remove the label from the exception_handler_label list
1995      and remove the associated NOTE_INSN_EH_REGION_BEG and
1996      NOTE_INSN_EH_REGION_END notes.  */
1997
1998   insn = b->head;
1999
2000   never_reached_warning (insn);
2001
2002   if (GET_CODE (insn) == CODE_LABEL)
2003     {
2004       rtx x, *prev = &exception_handler_labels;
2005
2006       for (x = exception_handler_labels; x; x = XEXP (x, 1))
2007         {
2008           if (XEXP (x, 0) == insn)
2009             {
2010               /* Found a match, splice this label out of the EH label list.  */
2011               *prev = XEXP (x, 1);
2012               XEXP (x, 1) = NULL_RTX;
2013               XEXP (x, 0) = NULL_RTX;
2014
2015               /* Remove the handler from all regions */
2016               remove_handler (insn);
2017               deleted_handler = 1;
2018               break;
2019             }
2020           prev = &XEXP (x, 1);
2021         }
2022     }
2023
2024   /* Include any jump table following the basic block.  */
2025   end = b->end;
2026   if (GET_CODE (end) == JUMP_INSN
2027       && (tmp = JUMP_LABEL (end)) != NULL_RTX
2028       && (tmp = NEXT_INSN (tmp)) != NULL_RTX
2029       && GET_CODE (tmp) == JUMP_INSN
2030       && (GET_CODE (PATTERN (tmp)) == ADDR_VEC
2031           || GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC))
2032     end = tmp;
2033
2034   /* Include any barrier that may follow the basic block.  */
2035   tmp = next_nonnote_insn (end);
2036   if (tmp && GET_CODE (tmp) == BARRIER)
2037     end = tmp;
2038
2039   /* Selectively delete the entire chain.  */
2040   flow_delete_insn_chain (insn, end);
2041
2042   /* Remove the edges into and out of this block.  Note that there may
2043      indeed be edges in, if we are removing an unreachable loop.  */
2044   {
2045     edge e, next, *q;
2046
2047     for (e = b->pred; e; e = next)
2048       {
2049         for (q = &e->src->succ; *q != e; q = &(*q)->succ_next)
2050           continue;
2051         *q = e->succ_next;
2052         next = e->pred_next;
2053         n_edges--;
2054         free (e);
2055       }
2056     for (e = b->succ; e; e = next)
2057       {
2058         for (q = &e->dest->pred; *q != e; q = &(*q)->pred_next)
2059           continue;
2060         *q = e->pred_next;
2061         next = e->succ_next;
2062         n_edges--;
2063         free (e);
2064       }
2065
2066     b->pred = NULL;
2067     b->succ = NULL;
2068   }
2069
2070   /* Remove the basic block from the array, and compact behind it.  */
2071   expunge_block (b);
2072
2073   return deleted_handler;
2074 }
2075
2076 /* Remove block B from the basic block array and compact behind it.  */
2077
2078 static void
2079 expunge_block (b)
2080      basic_block b;
2081 {
2082   int i, n = n_basic_blocks;
2083
2084   for (i = b->index; i + 1 < n; ++i)
2085     {
2086       basic_block x = BASIC_BLOCK (i + 1);
2087       BASIC_BLOCK (i) = x;
2088       x->index = i;
2089     }
2090
2091   basic_block_info->num_elements--;
2092   n_basic_blocks--;
2093 }
2094
2095 /* Delete INSN by patching it out.  Return the next insn.  */
2096
2097 rtx
2098 flow_delete_insn (insn)
2099      rtx insn;
2100 {
2101   rtx prev = PREV_INSN (insn);
2102   rtx next = NEXT_INSN (insn);
2103   rtx note;
2104
2105   PREV_INSN (insn) = NULL_RTX;
2106   NEXT_INSN (insn) = NULL_RTX;
2107   INSN_DELETED_P (insn) = 1;
2108
2109   if (prev)
2110     NEXT_INSN (prev) = next;
2111   if (next)
2112     PREV_INSN (next) = prev;
2113   else
2114     set_last_insn (prev);
2115
2116   if (GET_CODE (insn) == CODE_LABEL)
2117     remove_node_from_expr_list (insn, &nonlocal_goto_handler_labels);
2118
2119   /* If deleting a jump, decrement the use count of the label.  Deleting
2120      the label itself should happen in the normal course of block merging.  */
2121   if (GET_CODE (insn) == JUMP_INSN
2122       && JUMP_LABEL (insn)
2123       && GET_CODE (JUMP_LABEL (insn)) == CODE_LABEL)
2124     LABEL_NUSES (JUMP_LABEL (insn))--;
2125
2126   /* Also if deleting an insn that references a label.  */
2127   else if ((note = find_reg_note (insn, REG_LABEL, NULL_RTX)) != NULL_RTX
2128            && GET_CODE (XEXP (note, 0)) == CODE_LABEL)
2129     LABEL_NUSES (XEXP (note, 0))--;
2130
2131   return next;
2132 }
2133
2134 /* True if a given label can be deleted.  */
2135
2136 static int
2137 can_delete_label_p (label)
2138      rtx label;
2139 {
2140   rtx x;
2141
2142   if (LABEL_PRESERVE_P (label))
2143     return 0;
2144
2145   for (x = forced_labels; x; x = XEXP (x, 1))
2146     if (label == XEXP (x, 0))
2147       return 0;
2148   for (x = label_value_list; x; x = XEXP (x, 1))
2149     if (label == XEXP (x, 0))
2150       return 0;
2151   for (x = exception_handler_labels; x; x = XEXP (x, 1))
2152     if (label == XEXP (x, 0))
2153       return 0;
2154
2155   /* User declared labels must be preserved.  */
2156   if (LABEL_NAME (label) != 0)
2157     return 0;
2158
2159   return 1;
2160 }
2161
2162 static int
2163 tail_recursion_label_p (label)
2164      rtx label;
2165 {
2166   rtx x;
2167
2168   for (x = tail_recursion_label_list; x; x = XEXP (x, 1))
2169     if (label == XEXP (x, 0))
2170       return 1;
2171
2172   return 0;
2173 }
2174
2175 /* Blocks A and B are to be merged into a single block A.  The insns
2176    are already contiguous, hence `nomove'.  */
2177
2178 void
2179 merge_blocks_nomove (a, b)
2180      basic_block a, b;
2181 {
2182   edge e;
2183   rtx b_head, b_end, a_end;
2184   rtx del_first = NULL_RTX, del_last = NULL_RTX;
2185   int b_empty = 0;
2186
2187   /* If there was a CODE_LABEL beginning B, delete it.  */
2188   b_head = b->head;
2189   b_end = b->end;
2190   if (GET_CODE (b_head) == CODE_LABEL)
2191     {
2192       /* Detect basic blocks with nothing but a label.  This can happen
2193          in particular at the end of a function.  */
2194       if (b_head == b_end)
2195         b_empty = 1;
2196       del_first = del_last = b_head;
2197       b_head = NEXT_INSN (b_head);
2198     }
2199
2200   /* Delete the basic block note.  */
2201   if (NOTE_INSN_BASIC_BLOCK_P (b_head))
2202     {
2203       if (b_head == b_end)
2204         b_empty = 1;
2205       if (! del_last)
2206         del_first = b_head;
2207       del_last = b_head;
2208       b_head = NEXT_INSN (b_head);
2209     }
2210
2211   /* If there was a jump out of A, delete it.  */
2212   a_end = a->end;
2213   if (GET_CODE (a_end) == JUMP_INSN)
2214     {
2215       rtx prev;
2216
2217       for (prev = PREV_INSN (a_end); ; prev = PREV_INSN (prev))
2218         if (GET_CODE (prev) != NOTE
2219             || NOTE_LINE_NUMBER (prev) == NOTE_INSN_BASIC_BLOCK
2220             || prev == a->head)
2221           break;
2222
2223       del_first = a_end;
2224
2225 #ifdef HAVE_cc0
2226       /* If this was a conditional jump, we need to also delete
2227          the insn that set cc0.  */
2228       if (prev && sets_cc0_p (prev))
2229         {
2230           rtx tmp = prev;
2231           prev = prev_nonnote_insn (prev);
2232           if (!prev)
2233             prev = a->head;
2234           del_first = tmp;
2235         }
2236 #endif
2237
2238       a_end = prev;
2239     }
2240   else if (GET_CODE (NEXT_INSN (a_end)) == BARRIER)
2241     del_first = NEXT_INSN (a_end);
2242
2243   /* Delete everything marked above as well as crap that might be
2244      hanging out between the two blocks.  */
2245   flow_delete_insn_chain (del_first, del_last);
2246
2247   /* Normally there should only be one successor of A and that is B, but
2248      partway though the merge of blocks for conditional_execution we'll
2249      be merging a TEST block with THEN and ELSE successors.  Free the
2250      whole lot of them and hope the caller knows what they're doing.  */
2251   while (a->succ)
2252     remove_edge (a->succ);
2253
2254   /* Adjust the edges out of B for the new owner.  */
2255   for (e = b->succ; e; e = e->succ_next)
2256     e->src = a;
2257   a->succ = b->succ;
2258
2259   /* B hasn't quite yet ceased to exist.  Attempt to prevent mishap.  */
2260   b->pred = b->succ = NULL;
2261
2262   /* Reassociate the insns of B with A.  */
2263   if (!b_empty)
2264     {
2265       if (basic_block_for_insn)
2266         {
2267           BLOCK_FOR_INSN (b_head) = a;
2268           while (b_head != b_end)
2269             {
2270               b_head = NEXT_INSN (b_head);
2271               BLOCK_FOR_INSN (b_head) = a;
2272             }
2273         }
2274       a_end = b_end;
2275     }
2276   a->end = a_end;
2277
2278   expunge_block (b);
2279 }
2280
2281 /* Blocks A and B are to be merged into a single block.  A has no incoming
2282    fallthru edge, so it can be moved before B without adding or modifying
2283    any jumps (aside from the jump from A to B).  */
2284
2285 static int
2286 merge_blocks_move_predecessor_nojumps (a, b)
2287      basic_block a, b;
2288 {
2289   rtx start, end, barrier;
2290   int index;
2291
2292   start = a->head;
2293   end = a->end;
2294
2295   barrier = next_nonnote_insn (end);
2296   if (GET_CODE (barrier) != BARRIER)
2297     abort ();
2298   flow_delete_insn (barrier);
2299
2300   /* Move block and loop notes out of the chain so that we do not
2301      disturb their order.
2302
2303      ??? A better solution would be to squeeze out all the non-nested notes
2304      and adjust the block trees appropriately.   Even better would be to have
2305      a tighter connection between block trees and rtl so that this is not
2306      necessary.  */
2307   start = squeeze_notes (start, end);
2308
2309   /* Scramble the insn chain.  */
2310   if (end != PREV_INSN (b->head))
2311     reorder_insns (start, end, PREV_INSN (b->head));
2312
2313   if (rtl_dump_file)
2314     {
2315       fprintf (rtl_dump_file, "Moved block %d before %d and merged.\n",
2316                a->index, b->index);
2317     }
2318
2319   /* Swap the records for the two blocks around.  Although we are deleting B,
2320      A is now where B was and we want to compact the BB array from where
2321      A used to be.  */
2322   BASIC_BLOCK (a->index) = b;
2323   BASIC_BLOCK (b->index) = a;
2324   index = a->index;
2325   a->index = b->index;
2326   b->index = index;
2327
2328   /* Now blocks A and B are contiguous.  Merge them.  */
2329   merge_blocks_nomove (a, b);
2330
2331   return 1;
2332 }
2333
2334 /* Blocks A and B are to be merged into a single block.  B has no outgoing
2335    fallthru edge, so it can be moved after A without adding or modifying
2336    any jumps (aside from the jump from A to B).  */
2337
2338 static int
2339 merge_blocks_move_successor_nojumps (a, b)
2340      basic_block a, b;
2341 {
2342   rtx start, end, barrier;
2343
2344   start = b->head;
2345   end = b->end;
2346   barrier = NEXT_INSN (end);
2347
2348   /* Recognize a jump table following block B.  */
2349   if (GET_CODE (barrier) == CODE_LABEL
2350       && NEXT_INSN (barrier)
2351       && GET_CODE (NEXT_INSN (barrier)) == JUMP_INSN
2352       && (GET_CODE (PATTERN (NEXT_INSN (barrier))) == ADDR_VEC
2353           || GET_CODE (PATTERN (NEXT_INSN (barrier))) == ADDR_DIFF_VEC))
2354     {
2355       end = NEXT_INSN (barrier);
2356       barrier = NEXT_INSN (end);
2357     }
2358
2359   /* There had better have been a barrier there.  Delete it.  */
2360   if (GET_CODE (barrier) != BARRIER)
2361     abort ();
2362   flow_delete_insn (barrier);
2363
2364   /* Move block and loop notes out of the chain so that we do not
2365      disturb their order.
2366
2367      ??? A better solution would be to squeeze out all the non-nested notes
2368      and adjust the block trees appropriately.   Even better would be to have
2369      a tighter connection between block trees and rtl so that this is not
2370      necessary.  */
2371   start = squeeze_notes (start, end);
2372
2373   /* Scramble the insn chain.  */
2374   reorder_insns (start, end, a->end);
2375
2376   /* Now blocks A and B are contiguous.  Merge them.  */
2377   merge_blocks_nomove (a, b);
2378
2379   if (rtl_dump_file)
2380     {
2381       fprintf (rtl_dump_file, "Moved block %d after %d and merged.\n",
2382                b->index, a->index);
2383     }
2384
2385   return 1;
2386 }
2387
2388 /* Attempt to merge basic blocks that are potentially non-adjacent.
2389    Return true iff the attempt succeeded.  */
2390
2391 static int
2392 merge_blocks (e, b, c)
2393      edge e;
2394      basic_block b, c;
2395 {
2396   /* If C has a tail recursion label, do not merge.  There is no
2397      edge recorded from the call_placeholder back to this label, as
2398      that would make optimize_sibling_and_tail_recursive_calls more
2399      complex for no gain.  */
2400   if (GET_CODE (c->head) == CODE_LABEL
2401       && tail_recursion_label_p (c->head))
2402     return 0;
2403
2404   /* If B has a fallthru edge to C, no need to move anything.  */
2405   if (e->flags & EDGE_FALLTHRU)
2406     {
2407       merge_blocks_nomove (b, c);
2408
2409       if (rtl_dump_file)
2410         {
2411           fprintf (rtl_dump_file, "Merged %d and %d without moving.\n",
2412                    b->index, c->index);
2413         }
2414
2415       return 1;
2416     }
2417   else
2418     {
2419       edge tmp_edge;
2420       basic_block d;
2421       int c_has_outgoing_fallthru;
2422       int b_has_incoming_fallthru;
2423
2424       /* We must make sure to not munge nesting of exception regions,
2425          lexical blocks, and loop notes.
2426
2427          The first is taken care of by requiring that the active eh
2428          region at the end of one block always matches the active eh
2429          region at the beginning of the next block.
2430
2431          The later two are taken care of by squeezing out all the notes.  */
2432
2433       /* ???  A throw/catch edge (or any abnormal edge) should be rarely
2434          executed and we may want to treat blocks which have two out
2435          edges, one normal, one abnormal as only having one edge for
2436          block merging purposes.  */
2437
2438       for (tmp_edge = c->succ; tmp_edge; tmp_edge = tmp_edge->succ_next)
2439         if (tmp_edge->flags & EDGE_FALLTHRU)
2440           break;
2441       c_has_outgoing_fallthru = (tmp_edge != NULL);
2442
2443       for (tmp_edge = b->pred; tmp_edge; tmp_edge = tmp_edge->pred_next)
2444         if (tmp_edge->flags & EDGE_FALLTHRU)
2445           break;
2446       b_has_incoming_fallthru = (tmp_edge != NULL);
2447
2448       /* If B does not have an incoming fallthru, and the exception regions
2449          match, then it can be moved immediately before C without introducing
2450          or modifying jumps.
2451
2452          C can not be the first block, so we do not have to worry about
2453          accessing a non-existent block.  */
2454       d = BASIC_BLOCK (c->index - 1);
2455       if (! b_has_incoming_fallthru
2456           && d->eh_end == b->eh_beg
2457           && b->eh_end == c->eh_beg)
2458         return merge_blocks_move_predecessor_nojumps (b, c);
2459
2460       /* Otherwise, we're going to try to move C after B.  Make sure the
2461          exception regions match.
2462
2463          If B is the last basic block, then we must not try to access the
2464          block structure for block B + 1.  Luckily in that case we do not
2465          need to worry about matching exception regions.  */
2466       d = (b->index + 1 < n_basic_blocks ? BASIC_BLOCK (b->index + 1) : NULL);
2467       if (b->eh_end == c->eh_beg
2468           && (d == NULL || c->eh_end == d->eh_beg))
2469         {
2470           /* If C does not have an outgoing fallthru, then it can be moved
2471              immediately after B without introducing or modifying jumps.  */
2472           if (! c_has_outgoing_fallthru)
2473             return merge_blocks_move_successor_nojumps (b, c);
2474
2475           /* Otherwise, we'll need to insert an extra jump, and possibly
2476              a new block to contain it.  */
2477           /* ??? Not implemented yet.  */
2478         }
2479
2480       return 0;
2481     }
2482 }
2483
2484 /* Top level driver for merge_blocks.  */
2485
2486 static void
2487 try_merge_blocks ()
2488 {
2489   int i;
2490
2491   /* Attempt to merge blocks as made possible by edge removal.  If a block
2492      has only one successor, and the successor has only one predecessor,
2493      they may be combined.  */
2494
2495   for (i = 0; i < n_basic_blocks;)
2496     {
2497       basic_block c, b = BASIC_BLOCK (i);
2498       edge s;
2499
2500       /* A loop because chains of blocks might be combineable.  */
2501       while ((s = b->succ) != NULL
2502              && s->succ_next == NULL
2503              && (s->flags & EDGE_EH) == 0
2504              && (c = s->dest) != EXIT_BLOCK_PTR
2505              && c->pred->pred_next == NULL
2506              /* If the jump insn has side effects, we can't kill the edge.  */
2507              && (GET_CODE (b->end) != JUMP_INSN
2508                  || onlyjump_p (b->end))
2509              && merge_blocks (s, b, c))
2510         continue;
2511
2512       /* Don't get confused by the index shift caused by deleting blocks.  */
2513       i = b->index + 1;
2514     }
2515 }
2516
2517 /* The given edge should potentially be a fallthru edge.  If that is in
2518    fact true, delete the jump and barriers that are in the way.  */
2519
2520 void
2521 tidy_fallthru_edge (e, b, c)
2522      edge e;
2523      basic_block b, c;
2524 {
2525   rtx q;
2526
2527   /* ??? In a late-running flow pass, other folks may have deleted basic
2528      blocks by nopping out blocks, leaving multiple BARRIERs between here
2529      and the target label. They ought to be chastized and fixed.
2530
2531      We can also wind up with a sequence of undeletable labels between
2532      one block and the next.
2533
2534      So search through a sequence of barriers, labels, and notes for
2535      the head of block C and assert that we really do fall through.  */
2536
2537   if (next_real_insn (b->end) != next_real_insn (PREV_INSN (c->head)))
2538     return;
2539
2540   /* Remove what will soon cease being the jump insn from the source block.
2541      If block B consisted only of this single jump, turn it into a deleted
2542      note.  */
2543   q = b->end;
2544   if (GET_CODE (q) == JUMP_INSN
2545       && onlyjump_p (q)
2546       && (any_uncondjump_p (q)
2547           || (b->succ == e && e->succ_next == NULL)))
2548     {
2549 #ifdef HAVE_cc0
2550       /* If this was a conditional jump, we need to also delete
2551          the insn that set cc0.  */
2552       if (any_condjump_p (q) && sets_cc0_p (PREV_INSN (q)))
2553         q = PREV_INSN (q);
2554 #endif
2555
2556       if (b->head == q)
2557         {
2558           PUT_CODE (q, NOTE);
2559           NOTE_LINE_NUMBER (q) = NOTE_INSN_DELETED;
2560           NOTE_SOURCE_FILE (q) = 0;
2561         }
2562       else
2563         q = PREV_INSN (q);
2564
2565       b->end = q;
2566     }
2567
2568   /* Selectively unlink the sequence.  */
2569   if (q != PREV_INSN (c->head))
2570     flow_delete_insn_chain (NEXT_INSN (q), PREV_INSN (c->head));
2571
2572   e->flags |= EDGE_FALLTHRU;
2573 }
2574
2575 /* Fix up edges that now fall through, or rather should now fall through
2576    but previously required a jump around now deleted blocks.  Simplify
2577    the search by only examining blocks numerically adjacent, since this
2578    is how find_basic_blocks created them.  */
2579
2580 static void
2581 tidy_fallthru_edges ()
2582 {
2583   int i;
2584
2585   for (i = 1; i < n_basic_blocks; ++i)
2586     {
2587       basic_block b = BASIC_BLOCK (i - 1);
2588       basic_block c = BASIC_BLOCK (i);
2589       edge s;
2590
2591       /* We care about simple conditional or unconditional jumps with
2592          a single successor.
2593
2594          If we had a conditional branch to the next instruction when
2595          find_basic_blocks was called, then there will only be one
2596          out edge for the block which ended with the conditional
2597          branch (since we do not create duplicate edges).
2598
2599          Furthermore, the edge will be marked as a fallthru because we
2600          merge the flags for the duplicate edges.  So we do not want to
2601          check that the edge is not a FALLTHRU edge.  */
2602       if ((s = b->succ) != NULL
2603           && s->succ_next == NULL
2604           && s->dest == c
2605           /* If the jump insn has side effects, we can't tidy the edge.  */
2606           && (GET_CODE (b->end) != JUMP_INSN
2607               || onlyjump_p (b->end)))
2608         tidy_fallthru_edge (s, b, c);
2609     }
2610 }
2611 \f
2612 /* Perform data flow analysis.
2613    F is the first insn of the function; FLAGS is a set of PROP_* flags
2614    to be used in accumulating flow info.  */
2615
2616 void
2617 life_analysis (f, file, flags)
2618      rtx f;
2619      FILE *file;
2620      int flags;
2621 {
2622 #ifdef ELIMINABLE_REGS
2623   register int i;
2624   static struct {int from, to; } eliminables[] = ELIMINABLE_REGS;
2625 #endif
2626
2627   /* Record which registers will be eliminated.  We use this in
2628      mark_used_regs.  */
2629
2630   CLEAR_HARD_REG_SET (elim_reg_set);
2631
2632 #ifdef ELIMINABLE_REGS
2633   for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++)
2634     SET_HARD_REG_BIT (elim_reg_set, eliminables[i].from);
2635 #else
2636   SET_HARD_REG_BIT (elim_reg_set, FRAME_POINTER_REGNUM);
2637 #endif
2638
2639   if (! optimize)
2640     flags &= ~(PROP_LOG_LINKS | PROP_AUTOINC);
2641
2642   /* The post-reload life analysis have (on a global basis) the same
2643      registers live as was computed by reload itself.  elimination
2644      Otherwise offsets and such may be incorrect.
2645
2646      Reload will make some registers as live even though they do not
2647      appear in the rtl.
2648
2649      We don't want to create new auto-incs after reload, since they
2650      are unlikely to be useful and can cause problems with shared
2651      stack slots.  */
2652   if (reload_completed)
2653     flags &= ~(PROP_REG_INFO | PROP_AUTOINC);
2654
2655   /* We want alias analysis information for local dead store elimination.  */
2656   if (optimize && (flags & PROP_SCAN_DEAD_CODE))
2657     init_alias_analysis ();
2658
2659   /* Always remove no-op moves.  Do this before other processing so
2660      that we don't have to keep re-scanning them.  */
2661   delete_noop_moves (f);
2662
2663   /* Some targets can emit simpler epilogues if they know that sp was
2664      not ever modified during the function.  After reload, of course,
2665      we've already emitted the epilogue so there's no sense searching.  */
2666   if (! reload_completed)
2667     notice_stack_pointer_modification (f);
2668
2669   /* Allocate and zero out data structures that will record the
2670      data from lifetime analysis.  */
2671   allocate_reg_life_data ();
2672   allocate_bb_life_data ();
2673
2674   /* Find the set of registers live on function exit.  */
2675   mark_regs_live_at_end (EXIT_BLOCK_PTR->global_live_at_start);
2676
2677   /* "Update" life info from zero.  It'd be nice to begin the
2678      relaxation with just the exit and noreturn blocks, but that set
2679      is not immediately handy.  */
2680
2681   if (flags & PROP_REG_INFO)
2682     memset (regs_ever_live, 0, sizeof (regs_ever_live));
2683   update_life_info (NULL, UPDATE_LIFE_GLOBAL, flags);
2684
2685   /* Clean up.  */
2686   if (optimize && (flags & PROP_SCAN_DEAD_CODE))
2687     end_alias_analysis ();
2688
2689   if (file)
2690     dump_flow_info (file);
2691
2692   free_basic_block_vars (1);
2693 }
2694
2695 /* A subroutine of verify_wide_reg, called through for_each_rtx.
2696    Search for REGNO.  If found, abort if it is not wider than word_mode.  */
2697
2698 static int
2699 verify_wide_reg_1 (px, pregno)
2700      rtx *px;
2701      void *pregno;
2702 {
2703   rtx x = *px;
2704   unsigned int regno = *(int *) pregno;
2705
2706   if (GET_CODE (x) == REG && REGNO (x) == regno)
2707     {
2708       if (GET_MODE_BITSIZE (GET_MODE (x)) <= BITS_PER_WORD)
2709         abort ();
2710       return 1;
2711     }
2712   return 0;
2713 }
2714
2715 /* A subroutine of verify_local_live_at_start.  Search through insns
2716    between HEAD and END looking for register REGNO.  */
2717
2718 static void
2719 verify_wide_reg (regno, head, end)
2720      int regno;
2721      rtx head, end;
2722 {
2723   while (1)
2724     {
2725       if (INSN_P (head)
2726           && for_each_rtx (&PATTERN (head), verify_wide_reg_1, &regno))
2727         return;
2728       if (head == end)
2729         break;
2730       head = NEXT_INSN (head);
2731     }
2732
2733   /* We didn't find the register at all.  Something's way screwy.  */
2734   abort ();
2735 }
2736
2737 /* A subroutine of update_life_info.  Verify that there are no untoward
2738    changes in live_at_start during a local update.  */
2739
2740 static void
2741 verify_local_live_at_start (new_live_at_start, bb)
2742      regset new_live_at_start;
2743      basic_block bb;
2744 {
2745   if (reload_completed)
2746     {
2747       /* After reload, there are no pseudos, nor subregs of multi-word
2748          registers.  The regsets should exactly match.  */
2749       if (! REG_SET_EQUAL_P (new_live_at_start, bb->global_live_at_start))
2750         abort ();
2751     }
2752   else
2753     {
2754       int i;
2755
2756       /* Find the set of changed registers.  */
2757       XOR_REG_SET (new_live_at_start, bb->global_live_at_start);
2758
2759       EXECUTE_IF_SET_IN_REG_SET (new_live_at_start, 0, i,
2760         {
2761           /* No registers should die.  */
2762           if (REGNO_REG_SET_P (bb->global_live_at_start, i))
2763             abort ();
2764           /* Verify that the now-live register is wider than word_mode.  */
2765           verify_wide_reg (i, bb->head, bb->end);
2766         });
2767     }
2768 }
2769
2770 /* Updates life information starting with the basic blocks set in BLOCKS.
2771    If BLOCKS is null, consider it to be the universal set.
2772
2773    If EXTENT is UPDATE_LIFE_LOCAL, such as after splitting or peepholeing,
2774    we are only expecting local modifications to basic blocks.  If we find
2775    extra registers live at the beginning of a block, then we either killed
2776    useful data, or we have a broken split that wants data not provided.
2777    If we find registers removed from live_at_start, that means we have
2778    a broken peephole that is killing a register it shouldn't.
2779
2780    ??? This is not true in one situation -- when a pre-reload splitter
2781    generates subregs of a multi-word pseudo, current life analysis will
2782    lose the kill.  So we _can_ have a pseudo go live.  How irritating.
2783
2784    Including PROP_REG_INFO does not properly refresh regs_ever_live
2785    unless the caller resets it to zero.  */
2786
2787 void
2788 update_life_info (blocks, extent, prop_flags)
2789      sbitmap blocks;
2790      enum update_life_extent extent;
2791      int prop_flags;
2792 {
2793   regset tmp;
2794   regset_head tmp_head;
2795   int i;
2796
2797   tmp = INITIALIZE_REG_SET (tmp_head);
2798
2799   /* For a global update, we go through the relaxation process again.  */
2800   if (extent != UPDATE_LIFE_LOCAL)
2801     {
2802       calculate_global_regs_live (blocks, blocks,
2803                                   prop_flags & PROP_SCAN_DEAD_CODE);
2804
2805       /* If asked, remove notes from the blocks we'll update.  */
2806       if (extent == UPDATE_LIFE_GLOBAL_RM_NOTES)
2807         count_or_remove_death_notes (blocks, 1);
2808     }
2809
2810   if (blocks)
2811     {
2812       EXECUTE_IF_SET_IN_SBITMAP (blocks, 0, i,
2813         {
2814           basic_block bb = BASIC_BLOCK (i);
2815
2816           COPY_REG_SET (tmp, bb->global_live_at_end);
2817           propagate_block (bb, tmp, (regset) NULL, prop_flags);
2818
2819           if (extent == UPDATE_LIFE_LOCAL)
2820             verify_local_live_at_start (tmp, bb);
2821         });
2822     }
2823   else
2824     {
2825       for (i = n_basic_blocks - 1; i >= 0; --i)
2826         {
2827           basic_block bb = BASIC_BLOCK (i);
2828
2829           COPY_REG_SET (tmp, bb->global_live_at_end);
2830           propagate_block (bb, tmp, (regset) NULL, prop_flags);
2831
2832           if (extent == UPDATE_LIFE_LOCAL)
2833             verify_local_live_at_start (tmp, bb);
2834         }
2835     }
2836
2837   FREE_REG_SET (tmp);
2838
2839   if (prop_flags & PROP_REG_INFO)
2840     {
2841       /* The only pseudos that are live at the beginning of the function
2842          are those that were not set anywhere in the function.  local-alloc
2843          doesn't know how to handle these correctly, so mark them as not
2844          local to any one basic block.  */
2845       EXECUTE_IF_SET_IN_REG_SET (ENTRY_BLOCK_PTR->global_live_at_end,
2846                                  FIRST_PSEUDO_REGISTER, i,
2847                                  { REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL; });
2848
2849       /* We have a problem with any pseudoreg that lives across the setjmp.
2850          ANSI says that if a user variable does not change in value between
2851          the setjmp and the longjmp, then the longjmp preserves it.  This
2852          includes longjmp from a place where the pseudo appears dead.
2853          (In principle, the value still exists if it is in scope.)
2854          If the pseudo goes in a hard reg, some other value may occupy
2855          that hard reg where this pseudo is dead, thus clobbering the pseudo.
2856          Conclusion: such a pseudo must not go in a hard reg.  */
2857       EXECUTE_IF_SET_IN_REG_SET (regs_live_at_setjmp,
2858                                  FIRST_PSEUDO_REGISTER, i,
2859                                  {
2860                                    if (regno_reg_rtx[i] != 0)
2861                                      {
2862                                        REG_LIVE_LENGTH (i) = -1;
2863                                        REG_BASIC_BLOCK (i) = REG_BLOCK_UNKNOWN;
2864                                      }
2865                                  });
2866     }
2867 }
2868
2869 /* Free the variables allocated by find_basic_blocks.
2870
2871    KEEP_HEAD_END_P is non-zero if basic_block_info is not to be freed.  */
2872
2873 void
2874 free_basic_block_vars (keep_head_end_p)
2875      int keep_head_end_p;
2876 {
2877   if (basic_block_for_insn)
2878     {
2879       VARRAY_FREE (basic_block_for_insn);
2880       basic_block_for_insn = NULL;
2881     }
2882
2883   if (! keep_head_end_p)
2884     {
2885       clear_edges ();
2886       VARRAY_FREE (basic_block_info);
2887       n_basic_blocks = 0;
2888
2889       ENTRY_BLOCK_PTR->aux = NULL;
2890       ENTRY_BLOCK_PTR->global_live_at_end = NULL;
2891       EXIT_BLOCK_PTR->aux = NULL;
2892       EXIT_BLOCK_PTR->global_live_at_start = NULL;
2893     }
2894 }
2895
2896 /* Return nonzero if the destination of SET equals the source.  */
2897
2898 static int
2899 set_noop_p (set)
2900      rtx set;
2901 {
2902   rtx src = SET_SRC (set);
2903   rtx dst = SET_DEST (set);
2904
2905   if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
2906     {
2907       if (SUBREG_WORD (src) != SUBREG_WORD (dst))
2908         return 0;
2909       src = SUBREG_REG (src);
2910       dst = SUBREG_REG (dst);
2911     }
2912
2913   return (GET_CODE (src) == REG && GET_CODE (dst) == REG
2914           && REGNO (src) == REGNO (dst));
2915 }
2916
2917 /* Return nonzero if an insn consists only of SETs, each of which only sets a
2918    value to itself.  */
2919
2920 static int
2921 noop_move_p (insn)
2922      rtx insn;
2923 {
2924   rtx pat = PATTERN (insn);
2925
2926   /* Insns carrying these notes are useful later on.  */
2927   if (find_reg_note (insn, REG_EQUAL, NULL_RTX))
2928     return 0;
2929
2930   if (GET_CODE (pat) == SET && set_noop_p (pat))
2931     return 1;
2932
2933   if (GET_CODE (pat) == PARALLEL)
2934     {
2935       int i;
2936       /* If nothing but SETs of registers to themselves,
2937          this insn can also be deleted.  */
2938       for (i = 0; i < XVECLEN (pat, 0); i++)
2939         {
2940           rtx tem = XVECEXP (pat, 0, i);
2941
2942           if (GET_CODE (tem) == USE
2943               || GET_CODE (tem) == CLOBBER)
2944             continue;
2945
2946           if (GET_CODE (tem) != SET || ! set_noop_p (tem))
2947             return 0;
2948         }
2949
2950       return 1;
2951     }
2952   return 0;
2953 }
2954
2955 /* Delete any insns that copy a register to itself.  */
2956
2957 static void
2958 delete_noop_moves (f)
2959      rtx f;
2960 {
2961   rtx insn;
2962   for (insn = f; insn; insn = NEXT_INSN (insn))
2963     {
2964       if (GET_CODE (insn) == INSN && noop_move_p (insn))
2965         {
2966           PUT_CODE (insn, NOTE);
2967           NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
2968           NOTE_SOURCE_FILE (insn) = 0;
2969         }
2970     }
2971 }
2972
2973 /* Determine if the stack pointer is constant over the life of the function.
2974    Only useful before prologues have been emitted.  */
2975
2976 static void
2977 notice_stack_pointer_modification_1 (x, pat, data)
2978      rtx x;
2979      rtx pat ATTRIBUTE_UNUSED;
2980      void *data ATTRIBUTE_UNUSED;
2981 {
2982   if (x == stack_pointer_rtx
2983       /* The stack pointer is only modified indirectly as the result
2984          of a push until later in flow.  See the comments in rtl.texi
2985          regarding Embedded Side-Effects on Addresses.  */
2986       || (GET_CODE (x) == MEM
2987           && (GET_CODE (XEXP (x, 0)) == PRE_DEC
2988               || GET_CODE (XEXP (x, 0)) == PRE_INC
2989               || GET_CODE (XEXP (x, 0)) == POST_DEC
2990               || GET_CODE (XEXP (x, 0)) == POST_INC)
2991           && XEXP (XEXP (x, 0), 0) == stack_pointer_rtx))
2992     current_function_sp_is_unchanging = 0;
2993 }
2994
2995 static void
2996 notice_stack_pointer_modification (f)
2997      rtx f;
2998 {
2999   rtx insn;
3000
3001   /* Assume that the stack pointer is unchanging if alloca hasn't
3002      been used.  */
3003   current_function_sp_is_unchanging = !current_function_calls_alloca;
3004   if (! current_function_sp_is_unchanging)
3005     return;
3006
3007   for (insn = f; insn; insn = NEXT_INSN (insn))
3008     {
3009       if (INSN_P (insn))
3010         {
3011           /* Check if insn modifies the stack pointer.  */
3012           note_stores (PATTERN (insn), notice_stack_pointer_modification_1,
3013                        NULL);
3014           if (! current_function_sp_is_unchanging)
3015             return;
3016         }
3017     }
3018 }
3019
3020 /* Mark a register in SET.  Hard registers in large modes get all
3021    of their component registers set as well.  */
3022
3023 static void
3024 mark_reg (reg, xset)
3025      rtx reg;
3026      void *xset;
3027 {
3028   regset set = (regset) xset;
3029   int regno = REGNO (reg);
3030
3031   if (GET_MODE (reg) == BLKmode)
3032     abort ();
3033
3034   SET_REGNO_REG_SET (set, regno);
3035   if (regno < FIRST_PSEUDO_REGISTER)
3036     {
3037       int n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
3038       while (--n > 0)
3039         SET_REGNO_REG_SET (set, regno + n);
3040     }
3041 }
3042
3043 /* Mark those regs which are needed at the end of the function as live
3044    at the end of the last basic block.  */
3045
3046 static void
3047 mark_regs_live_at_end (set)
3048      regset set;
3049 {
3050   int i;
3051
3052   /* If exiting needs the right stack value, consider the stack pointer
3053      live at the end of the function.  */
3054   if ((HAVE_epilogue && reload_completed)
3055       || ! EXIT_IGNORE_STACK
3056       || (! FRAME_POINTER_REQUIRED
3057           && ! current_function_calls_alloca
3058           && flag_omit_frame_pointer)
3059       || current_function_sp_is_unchanging)
3060     {
3061       SET_REGNO_REG_SET (set, STACK_POINTER_REGNUM);
3062     }
3063
3064   /* Mark the frame pointer if needed at the end of the function.  If
3065      we end up eliminating it, it will be removed from the live list
3066      of each basic block by reload.  */
3067
3068   if (! reload_completed || frame_pointer_needed)
3069     {
3070       SET_REGNO_REG_SET (set, FRAME_POINTER_REGNUM);
3071 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3072       /* If they are different, also mark the hard frame pointer as live.  */
3073       if (! LOCAL_REGNO (HARD_FRAME_POINTER_REGNUM))
3074         SET_REGNO_REG_SET (set, HARD_FRAME_POINTER_REGNUM);
3075 #endif
3076     }
3077
3078 #ifdef PIC_OFFSET_TABLE_REGNUM
3079 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
3080   /* Many architectures have a GP register even without flag_pic.
3081      Assume the pic register is not in use, or will be handled by
3082      other means, if it is not fixed.  */
3083   if (fixed_regs[PIC_OFFSET_TABLE_REGNUM])
3084     SET_REGNO_REG_SET (set, PIC_OFFSET_TABLE_REGNUM);
3085 #endif
3086 #endif
3087
3088   /* Mark all global registers, and all registers used by the epilogue
3089      as being live at the end of the function since they may be
3090      referenced by our caller.  */
3091   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3092     if (global_regs[i] || EPILOGUE_USES (i))
3093       SET_REGNO_REG_SET (set, i);
3094
3095   /* Mark all call-saved registers that we actaully used.  */
3096   if (HAVE_epilogue && reload_completed)
3097     {
3098       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3099         if (regs_ever_live[i] && ! call_used_regs[i] && ! LOCAL_REGNO (i))
3100           SET_REGNO_REG_SET (set, i);
3101     }
3102
3103   /* Mark function return value.  */
3104   diddle_return_value (mark_reg, set);
3105 }
3106
3107 /* Callback function for for_each_successor_phi.  DATA is a regset.
3108    Sets the SRC_REGNO, the regno of the phi alternative for phi node
3109    INSN, in the regset.  */
3110
3111 static int
3112 set_phi_alternative_reg (insn, dest_regno, src_regno, data)
3113      rtx insn ATTRIBUTE_UNUSED;
3114      int dest_regno ATTRIBUTE_UNUSED;
3115      int src_regno;
3116      void *data;
3117 {
3118   regset live = (regset) data;
3119   SET_REGNO_REG_SET (live, src_regno);
3120   return 0;
3121 }
3122
3123 /* Propagate global life info around the graph of basic blocks.  Begin
3124    considering blocks with their corresponding bit set in BLOCKS_IN.
3125    If BLOCKS_IN is null, consider it the universal set.
3126
3127    BLOCKS_OUT is set for every block that was changed.  */
3128
3129 static void
3130 calculate_global_regs_live (blocks_in, blocks_out, flags)
3131      sbitmap blocks_in, blocks_out;
3132      int flags;
3133 {
3134   basic_block *queue, *qhead, *qtail, *qend;
3135   regset tmp, new_live_at_end;
3136   regset_head tmp_head;
3137   regset_head new_live_at_end_head;
3138   int i;
3139
3140   tmp = INITIALIZE_REG_SET (tmp_head);
3141   new_live_at_end = INITIALIZE_REG_SET (new_live_at_end_head);
3142
3143   /* Create a worklist.  Allocate an extra slot for ENTRY_BLOCK, and one
3144      because the `head == tail' style test for an empty queue doesn't
3145      work with a full queue.  */
3146   queue = (basic_block *) xmalloc ((n_basic_blocks + 2) * sizeof (*queue));
3147   qtail = queue;
3148   qhead = qend = queue + n_basic_blocks + 2;
3149
3150   /* Clear out the garbage that might be hanging out in bb->aux.  */
3151   for (i = n_basic_blocks - 1; i >= 0; --i)
3152     BASIC_BLOCK (i)->aux = NULL;
3153
3154   /* Queue the blocks set in the initial mask.  Do this in reverse block
3155      number order so that we are more likely for the first round to do
3156      useful work.  We use AUX non-null to flag that the block is queued.  */
3157   if (blocks_in)
3158     {
3159       EXECUTE_IF_SET_IN_SBITMAP (blocks_in, 0, i,
3160         {
3161           basic_block bb = BASIC_BLOCK (i);
3162           *--qhead = bb;
3163           bb->aux = bb;
3164         });
3165     }
3166   else
3167     {
3168       for (i = 0; i < n_basic_blocks; ++i)
3169         {
3170           basic_block bb = BASIC_BLOCK (i);
3171           *--qhead = bb;
3172           bb->aux = bb;
3173         }
3174     }
3175
3176   if (blocks_out)
3177     sbitmap_zero (blocks_out);
3178
3179   while (qhead != qtail)
3180     {
3181       int rescan, changed;
3182       basic_block bb;
3183       edge e;
3184
3185       bb = *qhead++;
3186       if (qhead == qend)
3187         qhead = queue;
3188       bb->aux = NULL;
3189
3190       /* Begin by propogating live_at_start from the successor blocks.  */
3191       CLEAR_REG_SET (new_live_at_end);
3192       for (e = bb->succ; e; e = e->succ_next)
3193         {
3194           basic_block sb = e->dest;
3195           IOR_REG_SET (new_live_at_end, sb->global_live_at_start);
3196         }
3197
3198       /* Force the stack pointer to be live -- which might not already be
3199          the case for blocks within infinite loops.  */
3200       SET_REGNO_REG_SET (new_live_at_end, STACK_POINTER_REGNUM);
3201
3202       /* Similarly for the frame pointer before reload.  Any reference
3203          to any pseudo before reload is a potential reference of the
3204          frame pointer.  */
3205       if (! reload_completed)
3206         SET_REGNO_REG_SET (new_live_at_end, FRAME_POINTER_REGNUM);
3207
3208       /* Regs used in phi nodes are not included in
3209          global_live_at_start, since they are live only along a
3210          particular edge.  Set those regs that are live because of a
3211          phi node alternative corresponding to this particular block.  */
3212       if (in_ssa_form)
3213         for_each_successor_phi (bb, &set_phi_alternative_reg,
3214                                 new_live_at_end);
3215
3216       if (bb == ENTRY_BLOCK_PTR)
3217         {
3218           COPY_REG_SET (bb->global_live_at_end, new_live_at_end);
3219           continue;
3220         }
3221
3222       /* On our first pass through this block, we'll go ahead and continue.
3223          Recognize first pass by local_set NULL.  On subsequent passes, we
3224          get to skip out early if live_at_end wouldn't have changed.  */
3225
3226       if (bb->local_set == NULL)
3227         {
3228           bb->local_set = OBSTACK_ALLOC_REG_SET (function_obstack);
3229           rescan = 1;
3230         }
3231       else
3232         {
3233           /* If any bits were removed from live_at_end, we'll have to
3234              rescan the block.  This wouldn't be necessary if we had
3235              precalculated local_live, however with PROP_SCAN_DEAD_CODE
3236              local_live is really dependent on live_at_end.  */
3237           CLEAR_REG_SET (tmp);
3238           rescan = bitmap_operation (tmp, bb->global_live_at_end,
3239                                      new_live_at_end, BITMAP_AND_COMPL);
3240
3241           if (! rescan)
3242             {
3243               /* Find the set of changed bits.  Take this opportunity
3244                  to notice that this set is empty and early out.  */
3245               CLEAR_REG_SET (tmp);
3246               changed = bitmap_operation (tmp, bb->global_live_at_end,
3247                                           new_live_at_end, BITMAP_XOR);
3248               if (! changed)
3249                 continue;
3250
3251               /* If any of the changed bits overlap with local_set,
3252                  we'll have to rescan the block.  Detect overlap by
3253                  the AND with ~local_set turning off bits.  */
3254               rescan = bitmap_operation (tmp, tmp, bb->local_set,
3255                                          BITMAP_AND_COMPL);
3256             }
3257         }
3258
3259       /* Let our caller know that BB changed enough to require its
3260          death notes updated.  */
3261       if (blocks_out)
3262         SET_BIT (blocks_out, bb->index);
3263
3264       if (! rescan)
3265         {
3266           /* Add to live_at_start the set of all registers in
3267              new_live_at_end that aren't in the old live_at_end.  */
3268
3269           bitmap_operation (tmp, new_live_at_end, bb->global_live_at_end,
3270                             BITMAP_AND_COMPL);
3271           COPY_REG_SET (bb->global_live_at_end, new_live_at_end);
3272
3273           changed = bitmap_operation (bb->global_live_at_start,
3274                                       bb->global_live_at_start,
3275                                       tmp, BITMAP_IOR);
3276           if (! changed)
3277             continue;
3278         }
3279       else
3280         {
3281           COPY_REG_SET (bb->global_live_at_end, new_live_at_end);
3282
3283           /* Rescan the block insn by insn to turn (a copy of) live_at_end
3284              into live_at_start.  */
3285           propagate_block (bb, new_live_at_end, bb->local_set, flags);
3286
3287           /* If live_at start didn't change, no need to go farther.  */
3288           if (REG_SET_EQUAL_P (bb->global_live_at_start, new_live_at_end))
3289             continue;
3290
3291           COPY_REG_SET (bb->global_live_at_start, new_live_at_end);
3292         }
3293
3294       /* Queue all predecessors of BB so that we may re-examine
3295          their live_at_end.  */
3296       for (e = bb->pred; e; e = e->pred_next)
3297         {
3298           basic_block pb = e->src;
3299           if (pb->aux == NULL)
3300             {
3301               *qtail++ = pb;
3302               if (qtail == qend)
3303                 qtail = queue;
3304               pb->aux = pb;
3305             }
3306         }
3307     }
3308
3309   FREE_REG_SET (tmp);
3310   FREE_REG_SET (new_live_at_end);
3311
3312   if (blocks_out)
3313     {
3314       EXECUTE_IF_SET_IN_SBITMAP (blocks_out, 0, i,
3315         {
3316           basic_block bb = BASIC_BLOCK (i);
3317           FREE_REG_SET (bb->local_set);
3318         });
3319     }
3320   else
3321     {
3322       for (i = n_basic_blocks - 1; i >= 0; --i)
3323         {
3324           basic_block bb = BASIC_BLOCK (i);
3325           FREE_REG_SET (bb->local_set);
3326         }
3327     }
3328
3329   free (queue);
3330 }
3331 \f
3332 /* Subroutines of life analysis.  */
3333
3334 /* Allocate the permanent data structures that represent the results
3335    of life analysis.  Not static since used also for stupid life analysis.  */
3336
3337 void
3338 allocate_bb_life_data ()
3339 {
3340   register int i;
3341
3342   for (i = 0; i < n_basic_blocks; i++)
3343     {
3344       basic_block bb = BASIC_BLOCK (i);
3345
3346       bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (function_obstack);
3347       bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (function_obstack);
3348     }
3349
3350   ENTRY_BLOCK_PTR->global_live_at_end
3351     = OBSTACK_ALLOC_REG_SET (function_obstack);
3352   EXIT_BLOCK_PTR->global_live_at_start
3353     = OBSTACK_ALLOC_REG_SET (function_obstack);
3354
3355   regs_live_at_setjmp = OBSTACK_ALLOC_REG_SET (function_obstack);
3356 }
3357
3358 void
3359 allocate_reg_life_data ()
3360 {
3361   int i;
3362
3363   max_regno = max_reg_num ();
3364
3365   /* Recalculate the register space, in case it has grown.  Old style
3366      vector oriented regsets would set regset_{size,bytes} here also.  */
3367   allocate_reg_info (max_regno, FALSE, FALSE);
3368
3369   /* Reset all the data we'll collect in propagate_block and its
3370      subroutines.  */
3371   for (i = 0; i < max_regno; i++)
3372     {
3373       REG_N_SETS (i) = 0;
3374       REG_N_REFS (i) = 0;
3375       REG_N_DEATHS (i) = 0;
3376       REG_N_CALLS_CROSSED (i) = 0;
3377       REG_LIVE_LENGTH (i) = 0;
3378       REG_BASIC_BLOCK (i) = REG_BLOCK_UNKNOWN;
3379     }
3380 }
3381
3382 /* Delete dead instructions for propagate_block.  */
3383
3384 static void
3385 propagate_block_delete_insn (bb, insn)
3386      basic_block bb;
3387      rtx insn;
3388 {
3389   rtx inote = find_reg_note (insn, REG_LABEL, NULL_RTX);
3390
3391   /* If the insn referred to a label, and that label was attached to
3392      an ADDR_VEC, it's safe to delete the ADDR_VEC.  In fact, it's
3393      pretty much mandatory to delete it, because the ADDR_VEC may be
3394      referencing labels that no longer exist.  */
3395
3396   if (inote)
3397     {
3398       rtx label = XEXP (inote, 0);
3399       rtx next;
3400
3401       if (LABEL_NUSES (label) == 1
3402           && (next = next_nonnote_insn (label)) != NULL
3403           && GET_CODE (next) == JUMP_INSN
3404           && (GET_CODE (PATTERN (next)) == ADDR_VEC
3405               || GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC))
3406         {
3407           rtx pat = PATTERN (next);
3408           int diff_vec_p = GET_CODE (pat) == ADDR_DIFF_VEC;
3409           int len = XVECLEN (pat, diff_vec_p);
3410           int i;
3411
3412           for (i = 0; i < len; i++)
3413             LABEL_NUSES (XEXP (XVECEXP (pat, diff_vec_p, i), 0))--;
3414
3415           flow_delete_insn (next);
3416         }
3417     }
3418
3419   if (bb->end == insn)
3420     bb->end = PREV_INSN (insn);
3421   flow_delete_insn (insn);
3422 }
3423
3424 /* Delete dead libcalls for propagate_block.  Return the insn
3425    before the libcall.  */
3426
3427 static rtx
3428 propagate_block_delete_libcall (bb, insn, note)
3429      basic_block bb;
3430      rtx insn, note;
3431 {
3432   rtx first = XEXP (note, 0);
3433   rtx before = PREV_INSN (first);
3434
3435   if (insn == bb->end)
3436     bb->end = before;
3437
3438   flow_delete_insn_chain (first, insn);
3439   return before;
3440 }
3441
3442 /* Update the life-status of regs for one insn.  Return the previous insn.  */
3443
3444 rtx
3445 propagate_one_insn (pbi, insn)
3446      struct propagate_block_info *pbi;
3447      rtx insn;
3448 {
3449   rtx prev = PREV_INSN (insn);
3450   int flags = pbi->flags;
3451   int insn_is_dead = 0;
3452   int libcall_is_dead = 0;
3453   rtx note;
3454   int i;
3455
3456   if (! INSN_P (insn))
3457     return prev;
3458
3459   note = find_reg_note (insn, REG_RETVAL, NULL_RTX);
3460   if (flags & PROP_SCAN_DEAD_CODE)
3461     {
3462       insn_is_dead = insn_dead_p (pbi, PATTERN (insn), 0,
3463                                   REG_NOTES (insn));
3464       libcall_is_dead = (insn_is_dead && note != 0
3465                          && libcall_dead_p (pbi, note, insn));
3466     }
3467
3468   /* We almost certainly don't want to delete prologue or epilogue
3469      instructions.  Warn about probable compiler losage.  */
3470   if (insn_is_dead
3471       && reload_completed
3472       && (((HAVE_epilogue || HAVE_prologue)
3473            && prologue_epilogue_contains (insn))
3474           || (HAVE_sibcall_epilogue
3475               && sibcall_epilogue_contains (insn)))
3476       && find_reg_note (insn, REG_MAYBE_DEAD, NULL_RTX) == 0)
3477     {
3478       if (flags & PROP_KILL_DEAD_CODE)
3479         {
3480           warning ("ICE: would have deleted prologue/epilogue insn");
3481           if (!inhibit_warnings)
3482             debug_rtx (insn);
3483         }
3484       libcall_is_dead = insn_is_dead = 0;
3485     }
3486
3487   /* If an instruction consists of just dead store(s) on final pass,
3488      delete it.  */
3489   if ((flags & PROP_KILL_DEAD_CODE) && insn_is_dead)
3490     {
3491       /* Record sets.  Do this even for dead instructions, since they
3492          would have killed the values if they hadn't been deleted.  */
3493       mark_set_regs (pbi, PATTERN (insn), insn);
3494
3495       /* CC0 is now known to be dead.  Either this insn used it,
3496          in which case it doesn't anymore, or clobbered it,
3497          so the next insn can't use it.  */
3498       pbi->cc0_live = 0;
3499
3500       if (libcall_is_dead)
3501         {
3502           prev = propagate_block_delete_libcall (pbi->bb, insn, note);
3503           insn = NEXT_INSN (prev);
3504         }
3505       else
3506         propagate_block_delete_insn (pbi->bb, insn);
3507
3508       return prev;
3509     }
3510
3511   /* See if this is an increment or decrement that can be merged into
3512      a following memory address.  */
3513 #ifdef AUTO_INC_DEC
3514   {
3515     register rtx x = single_set (insn);
3516
3517     /* Does this instruction increment or decrement a register?  */
3518     if ((flags & PROP_AUTOINC)
3519         && x != 0
3520         && GET_CODE (SET_DEST (x)) == REG
3521         && (GET_CODE (SET_SRC (x)) == PLUS
3522             || GET_CODE (SET_SRC (x)) == MINUS)
3523         && XEXP (SET_SRC (x), 0) == SET_DEST (x)
3524         && GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
3525         /* Ok, look for a following memory ref we can combine with.
3526            If one is found, change the memory ref to a PRE_INC
3527            or PRE_DEC, cancel this insn, and return 1.
3528            Return 0 if nothing has been done.  */
3529         && try_pre_increment_1 (pbi, insn))
3530       return prev;
3531   }
3532 #endif /* AUTO_INC_DEC */
3533
3534   CLEAR_REG_SET (pbi->new_set);
3535
3536   /* If this is not the final pass, and this insn is copying the value of
3537      a library call and it's dead, don't scan the insns that perform the
3538      library call, so that the call's arguments are not marked live.  */
3539   if (libcall_is_dead)
3540     {
3541       /* Record the death of the dest reg.  */
3542       mark_set_regs (pbi, PATTERN (insn), insn);
3543
3544       insn = XEXP (note, 0);
3545       return PREV_INSN (insn);
3546     }
3547   else if (GET_CODE (PATTERN (insn)) == SET
3548            && SET_DEST (PATTERN (insn)) == stack_pointer_rtx
3549            && GET_CODE (SET_SRC (PATTERN (insn))) == PLUS
3550            && XEXP (SET_SRC (PATTERN (insn)), 0) == stack_pointer_rtx
3551            && GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 1)) == CONST_INT)
3552     /* We have an insn to pop a constant amount off the stack.
3553        (Such insns use PLUS regardless of the direction of the stack,
3554        and any insn to adjust the stack by a constant is always a pop.)
3555        These insns, if not dead stores, have no effect on life.  */
3556     ;
3557   else
3558     {
3559       /* Any regs live at the time of a call instruction must not go
3560          in a register clobbered by calls.  Find all regs now live and
3561          record this for them.  */
3562
3563       if (GET_CODE (insn) == CALL_INSN && (flags & PROP_REG_INFO))
3564         EXECUTE_IF_SET_IN_REG_SET (pbi->reg_live, 0, i,
3565                                    { REG_N_CALLS_CROSSED (i)++; });
3566
3567       /* Record sets.  Do this even for dead instructions, since they
3568          would have killed the values if they hadn't been deleted.  */
3569       mark_set_regs (pbi, PATTERN (insn), insn);
3570
3571       if (GET_CODE (insn) == CALL_INSN)
3572         {
3573           register int i;
3574           rtx note, cond;
3575
3576           cond = NULL_RTX;
3577           if (GET_CODE (PATTERN (insn)) == COND_EXEC)
3578             cond = COND_EXEC_TEST (PATTERN (insn));
3579
3580           /* Non-constant calls clobber memory.  */
3581           if (! CONST_CALL_P (insn))
3582             free_EXPR_LIST_list (&pbi->mem_set_list);
3583
3584           /* There may be extra registers to be clobbered.  */
3585           for (note = CALL_INSN_FUNCTION_USAGE (insn);
3586                note;
3587                note = XEXP (note, 1))
3588             if (GET_CODE (XEXP (note, 0)) == CLOBBER)
3589               mark_set_1 (pbi, CLOBBER, XEXP (XEXP (note, 0), 0),
3590                           cond, insn, pbi->flags);
3591
3592           /* Calls change all call-used and global registers.  */
3593           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3594             if (call_used_regs[i] && ! global_regs[i]
3595                 && ! fixed_regs[i])
3596               {
3597                 /* We do not want REG_UNUSED notes for these registers.  */
3598                 mark_set_1 (pbi, CLOBBER, gen_rtx_REG (reg_raw_mode[i], i),
3599                             cond, insn,
3600                             pbi->flags & ~(PROP_DEATH_NOTES | PROP_REG_INFO));
3601               }
3602         }
3603
3604       /* If an insn doesn't use CC0, it becomes dead since we assume
3605          that every insn clobbers it.  So show it dead here;
3606          mark_used_regs will set it live if it is referenced.  */
3607       pbi->cc0_live = 0;
3608
3609       /* Record uses.  */
3610       if (! insn_is_dead)
3611         mark_used_regs (pbi, PATTERN (insn), NULL_RTX, insn);
3612
3613       /* Sometimes we may have inserted something before INSN (such as a move)
3614          when we make an auto-inc.  So ensure we will scan those insns.  */
3615 #ifdef AUTO_INC_DEC
3616       prev = PREV_INSN (insn);
3617 #endif
3618
3619       if (! insn_is_dead && GET_CODE (insn) == CALL_INSN)
3620         {
3621           register int i;
3622           rtx note, cond;
3623
3624           cond = NULL_RTX;
3625           if (GET_CODE (PATTERN (insn)) == COND_EXEC)
3626             cond = COND_EXEC_TEST (PATTERN (insn));
3627
3628           /* Calls use their arguments.  */
3629           for (note = CALL_INSN_FUNCTION_USAGE (insn);
3630                note;
3631                note = XEXP (note, 1))
3632             if (GET_CODE (XEXP (note, 0)) == USE)
3633               mark_used_regs (pbi, XEXP (XEXP (note, 0), 0),
3634                               cond, insn);
3635
3636           /* The stack ptr is used (honorarily) by a CALL insn.  */
3637           SET_REGNO_REG_SET (pbi->reg_live, STACK_POINTER_REGNUM);
3638
3639           /* Calls may also reference any of the global registers,
3640              so they are made live.  */
3641           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3642             if (global_regs[i])
3643               mark_used_reg (pbi, gen_rtx_REG (reg_raw_mode[i], i),
3644                              cond, insn);
3645         }
3646     }
3647
3648   /* On final pass, update counts of how many insns in which each reg
3649      is live.  */
3650   if (flags & PROP_REG_INFO)
3651     EXECUTE_IF_SET_IN_REG_SET (pbi->reg_live, 0, i,
3652                                { REG_LIVE_LENGTH (i)++; });
3653
3654   return prev;
3655 }
3656
3657 /* Initialize a propagate_block_info struct for public consumption.
3658    Note that the structure itself is opaque to this file, but that
3659    the user can use the regsets provided here.  */
3660
3661 struct propagate_block_info *
3662 init_propagate_block_info (bb, live, local_set, flags)
3663      basic_block bb;
3664      regset live;
3665      regset local_set;
3666      int flags;
3667 {
3668   struct propagate_block_info *pbi = xmalloc (sizeof (*pbi));
3669
3670   pbi->bb = bb;
3671   pbi->reg_live = live;
3672   pbi->mem_set_list = NULL_RTX;
3673   pbi->local_set = local_set;
3674   pbi->cc0_live = 0;
3675   pbi->flags = flags;
3676
3677   if (flags & (PROP_LOG_LINKS | PROP_AUTOINC))
3678     pbi->reg_next_use = (rtx *) xcalloc (max_reg_num (), sizeof (rtx));
3679   else
3680     pbi->reg_next_use = NULL;
3681
3682   pbi->new_set = BITMAP_XMALLOC ();
3683
3684 #ifdef HAVE_conditional_execution
3685   pbi->reg_cond_dead = splay_tree_new (splay_tree_compare_ints, NULL,
3686                                        free_reg_cond_life_info);
3687   pbi->reg_cond_reg = BITMAP_XMALLOC ();
3688
3689   /* If this block ends in a conditional branch, for each register live
3690      from one side of the branch and not the other, record the register
3691      as conditionally dead.  */
3692   if ((flags & (PROP_DEATH_NOTES | PROP_SCAN_DEAD_CODE))
3693       && GET_CODE (bb->end) == JUMP_INSN
3694       && any_condjump_p (bb->end))
3695     {
3696       regset_head diff_head;
3697       regset diff = INITIALIZE_REG_SET (diff_head);
3698       basic_block bb_true, bb_false;
3699       rtx cond_true, cond_false, set_src;
3700       int i;
3701
3702       /* Identify the successor blocks.  */
3703       bb_true = bb->succ->dest;
3704       if (bb->succ->succ_next != NULL)
3705         {
3706           bb_false = bb->succ->succ_next->dest;
3707
3708           if (bb->succ->flags & EDGE_FALLTHRU)
3709             {
3710               basic_block t = bb_false;
3711               bb_false = bb_true;
3712               bb_true = t;
3713             }
3714           else if (! (bb->succ->succ_next->flags & EDGE_FALLTHRU))
3715             abort ();
3716         }
3717       else
3718         {
3719           /* This can happen with a conditional jump to the next insn.  */
3720           if (JUMP_LABEL (bb->end) != bb_true->head)
3721             abort ();
3722
3723           /* Simplest way to do nothing.  */
3724           bb_false = bb_true;
3725         }
3726
3727       /* Extract the condition from the branch.  */
3728       set_src = SET_SRC (pc_set (bb->end));
3729       cond_true = XEXP (set_src, 0);
3730       cond_false = gen_rtx_fmt_ee (reverse_condition (GET_CODE (cond_true)),
3731                                    GET_MODE (cond_true), XEXP (cond_true, 0),
3732                                    XEXP (cond_true, 1));
3733       if (GET_CODE (XEXP (set_src, 1)) == PC)
3734         {
3735           rtx t = cond_false;
3736           cond_false = cond_true;
3737           cond_true = t;
3738         }
3739
3740       /* Compute which register lead different lives in the successors.  */
3741       if (bitmap_operation (diff, bb_true->global_live_at_start,
3742                             bb_false->global_live_at_start, BITMAP_XOR))
3743         {
3744           rtx reg = XEXP (cond_true, 0);
3745
3746           if (GET_CODE (reg) == SUBREG)
3747             reg = SUBREG_REG (reg);
3748
3749           if (GET_CODE (reg) != REG)
3750             abort ();
3751
3752           SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (reg));
3753
3754           /* For each such register, mark it conditionally dead.  */
3755           EXECUTE_IF_SET_IN_REG_SET
3756             (diff, 0, i,
3757              {
3758                struct reg_cond_life_info *rcli;
3759                rtx cond;
3760
3761                rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
3762
3763                if (REGNO_REG_SET_P (bb_true->global_live_at_start, i))
3764                  cond = cond_false;
3765                else
3766                  cond = cond_true;
3767                rcli->condition = alloc_EXPR_LIST (0, cond, NULL_RTX);
3768
3769                splay_tree_insert (pbi->reg_cond_dead, i,
3770                                   (splay_tree_value) rcli);
3771              });
3772         }
3773
3774       FREE_REG_SET (diff);
3775     }
3776 #endif
3777
3778   /* If this block has no successors, any stores to the frame that aren't
3779      used later in the block are dead.  So make a pass over the block
3780      recording any such that are made and show them dead at the end.  We do
3781      a very conservative and simple job here.  */
3782   if (optimize
3783       && ! (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
3784             && (TYPE_RETURNS_STACK_DEPRESSED
3785                 (TREE_TYPE (current_function_decl))))
3786       && (flags & PROP_SCAN_DEAD_CODE)
3787       && (bb->succ == NULL
3788           || (bb->succ->succ_next == NULL
3789               && bb->succ->dest == EXIT_BLOCK_PTR)))
3790     {
3791       rtx insn;
3792       for (insn = bb->end; insn != bb->head; insn = PREV_INSN (insn))
3793         if (GET_CODE (insn) == INSN
3794             && GET_CODE (PATTERN (insn)) == SET
3795             && GET_CODE (SET_DEST (PATTERN (insn))) == MEM)
3796           {
3797             rtx mem = SET_DEST (PATTERN (insn));
3798
3799             if (XEXP (mem, 0) == frame_pointer_rtx
3800                 || (GET_CODE (XEXP (mem, 0)) == PLUS
3801                     && XEXP (XEXP (mem, 0), 0) == frame_pointer_rtx
3802                     && GET_CODE (XEXP (XEXP (mem, 0), 1)) == CONST_INT))
3803               pbi->mem_set_list = alloc_EXPR_LIST (0, mem, pbi->mem_set_list);
3804           }
3805     }
3806
3807   return pbi;
3808 }
3809
3810 /* Release a propagate_block_info struct.  */
3811
3812 void
3813 free_propagate_block_info (pbi)
3814      struct propagate_block_info *pbi;
3815 {
3816   free_EXPR_LIST_list (&pbi->mem_set_list);
3817
3818   BITMAP_XFREE (pbi->new_set);
3819
3820 #ifdef HAVE_conditional_execution
3821   splay_tree_delete (pbi->reg_cond_dead);
3822   BITMAP_XFREE (pbi->reg_cond_reg);
3823 #endif
3824
3825   if (pbi->reg_next_use)
3826     free (pbi->reg_next_use);
3827
3828   free (pbi);
3829 }
3830
3831 /* Compute the registers live at the beginning of a basic block BB from
3832    those live at the end.
3833
3834    When called, REG_LIVE contains those live at the end.  On return, it
3835    contains those live at the beginning.
3836
3837    LOCAL_SET, if non-null, will be set with all registers killed by
3838    this basic block.  */
3839
3840 void
3841 propagate_block (bb, live, local_set, flags)
3842      basic_block bb;
3843      regset live;
3844      regset local_set;
3845      int flags;
3846 {
3847   struct propagate_block_info *pbi;
3848   rtx insn, prev;
3849
3850   pbi = init_propagate_block_info (bb, live, local_set, flags);
3851
3852   if (flags & PROP_REG_INFO)
3853     {
3854       register int i;
3855
3856       /* Process the regs live at the end of the block.
3857          Mark them as not local to any one basic block.  */
3858       EXECUTE_IF_SET_IN_REG_SET (live, 0, i,
3859                                  { REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL; });
3860     }
3861
3862   /* Scan the block an insn at a time from end to beginning.  */
3863
3864   for (insn = bb->end;; insn = prev)
3865     {
3866       /* If this is a call to `setjmp' et al, warn if any
3867          non-volatile datum is live.  */
3868       if ((flags & PROP_REG_INFO)
3869           && GET_CODE (insn) == NOTE
3870           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
3871         IOR_REG_SET (regs_live_at_setjmp, pbi->reg_live);
3872
3873       prev = propagate_one_insn (pbi, insn);
3874
3875       if (insn == bb->head)
3876         break;
3877     }
3878
3879   free_propagate_block_info (pbi);
3880 }
3881 \f
3882 /* Return 1 if X (the body of an insn, or part of it) is just dead stores
3883    (SET expressions whose destinations are registers dead after the insn).
3884    NEEDED is the regset that says which regs are alive after the insn.
3885
3886    Unless CALL_OK is non-zero, an insn is needed if it contains a CALL.
3887
3888    If X is the entire body of an insn, NOTES contains the reg notes
3889    pertaining to the insn.  */
3890
3891 static int
3892 insn_dead_p (pbi, x, call_ok, notes)
3893      struct propagate_block_info *pbi;
3894      rtx x;
3895      int call_ok;
3896      rtx notes ATTRIBUTE_UNUSED;
3897 {
3898   enum rtx_code code = GET_CODE (x);
3899
3900 #ifdef AUTO_INC_DEC
3901   /* If flow is invoked after reload, we must take existing AUTO_INC
3902      expresions into account.  */
3903   if (reload_completed)
3904     {
3905       for (; notes; notes = XEXP (notes, 1))
3906         {
3907           if (REG_NOTE_KIND (notes) == REG_INC)
3908             {
3909               int regno = REGNO (XEXP (notes, 0));
3910
3911               /* Don't delete insns to set global regs.  */
3912               if ((regno < FIRST_PSEUDO_REGISTER && global_regs[regno])
3913                   || REGNO_REG_SET_P (pbi->reg_live, regno))
3914                 return 0;
3915             }
3916         }
3917     }
3918 #endif
3919
3920   /* If setting something that's a reg or part of one,
3921      see if that register's altered value will be live.  */
3922
3923   if (code == SET)
3924     {
3925       rtx r = SET_DEST (x);
3926
3927 #ifdef HAVE_cc0
3928       if (GET_CODE (r) == CC0)
3929         return ! pbi->cc0_live;
3930 #endif
3931
3932       /* A SET that is a subroutine call cannot be dead.  */
3933       if (GET_CODE (SET_SRC (x)) == CALL)
3934         {
3935           if (! call_ok)
3936             return 0;
3937         }
3938
3939       /* Don't eliminate loads from volatile memory or volatile asms.  */
3940       else if (volatile_refs_p (SET_SRC (x)))
3941         return 0;
3942
3943       if (GET_CODE (r) == MEM)
3944         {
3945           rtx temp;
3946
3947           if (MEM_VOLATILE_P (r))
3948             return 0;
3949
3950           /* Walk the set of memory locations we are currently tracking
3951              and see if one is an identical match to this memory location.
3952              If so, this memory write is dead (remember, we're walking
3953              backwards from the end of the block to the start).  */
3954           temp = pbi->mem_set_list;
3955           while (temp)
3956             {
3957               if (rtx_equal_p (XEXP (temp, 0), r))
3958                 return 1;
3959               temp = XEXP (temp, 1);
3960             }
3961         }
3962       else
3963         {
3964           while (GET_CODE (r) == SUBREG
3965                  || GET_CODE (r) == STRICT_LOW_PART
3966                  || GET_CODE (r) == ZERO_EXTRACT)
3967             r = XEXP (r, 0);
3968
3969           if (GET_CODE (r) == REG)
3970             {
3971               int regno = REGNO (r);
3972
3973               /* Obvious.  */
3974               if (REGNO_REG_SET_P (pbi->reg_live, regno))
3975                 return 0;
3976
3977               /* If this is a hard register, verify that subsequent
3978                  words are not needed.  */
3979               if (regno < FIRST_PSEUDO_REGISTER)
3980                 {
3981                   int n = HARD_REGNO_NREGS (regno, GET_MODE (r));
3982
3983                   while (--n > 0)
3984                     if (REGNO_REG_SET_P (pbi->reg_live, regno+n))
3985                       return 0;
3986                 }
3987
3988               /* Don't delete insns to set global regs.  */
3989               if (regno < FIRST_PSEUDO_REGISTER && global_regs[regno])
3990                 return 0;
3991
3992               /* Make sure insns to set the stack pointer aren't deleted.  */
3993               if (regno == STACK_POINTER_REGNUM)
3994                 return 0;
3995
3996               /* Make sure insns to set the frame pointer aren't deleted.  */
3997               if (regno == FRAME_POINTER_REGNUM
3998                   && (! reload_completed || frame_pointer_needed))
3999                 return 0;
4000 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
4001               if (regno == HARD_FRAME_POINTER_REGNUM
4002                   && (! reload_completed || frame_pointer_needed))
4003                 return 0;
4004 #endif
4005
4006 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4007               /* Make sure insns to set arg pointer are never deleted
4008                  (if the arg pointer isn't fixed, there will be a USE
4009                  for it, so we can treat it normally).  */
4010               if (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
4011                 return 0;
4012 #endif
4013
4014 #ifdef PIC_OFFSET_TABLE_REGNUM
4015               /* Before reload, do not allow sets of the pic register
4016                  to be deleted.  Reload can insert references to
4017                  constant pool memory anywhere in the function, making
4018                  the PIC register live where it wasn't before.  */
4019               if (regno == PIC_OFFSET_TABLE_REGNUM && fixed_regs[regno]
4020                   && ! reload_completed)
4021                 return 0;
4022 #endif
4023
4024               /* Otherwise, the set is dead.  */
4025               return 1;
4026             }
4027         }
4028     }
4029
4030   /* If performing several activities, insn is dead if each activity
4031      is individually dead.  Also, CLOBBERs and USEs can be ignored; a
4032      CLOBBER or USE that's inside a PARALLEL doesn't make the insn
4033      worth keeping.  */
4034   else if (code == PARALLEL)
4035     {
4036       int i = XVECLEN (x, 0);
4037
4038       for (i--; i >= 0; i--)
4039         if (GET_CODE (XVECEXP (x, 0, i)) != CLOBBER
4040             && GET_CODE (XVECEXP (x, 0, i)) != USE
4041             && ! insn_dead_p (pbi, XVECEXP (x, 0, i), call_ok, NULL_RTX))
4042           return 0;
4043
4044       return 1;
4045     }
4046
4047   /* A CLOBBER of a pseudo-register that is dead serves no purpose.  That
4048      is not necessarily true for hard registers.  */
4049   else if (code == CLOBBER && GET_CODE (XEXP (x, 0)) == REG
4050            && REGNO (XEXP (x, 0)) >= FIRST_PSEUDO_REGISTER
4051            && ! REGNO_REG_SET_P (pbi->reg_live, REGNO (XEXP (x, 0))))
4052     return 1;
4053
4054   /* We do not check other CLOBBER or USE here.  An insn consisting of just
4055      a CLOBBER or just a USE should not be deleted.  */
4056   return 0;
4057 }
4058
4059 /* If INSN is the last insn in a libcall, and assuming INSN is dead,
4060    return 1 if the entire library call is dead.
4061    This is true if INSN copies a register (hard or pseudo)
4062    and if the hard return reg of the call insn is dead.
4063    (The caller should have tested the destination of the SET inside
4064    INSN already for death.)
4065
4066    If this insn doesn't just copy a register, then we don't
4067    have an ordinary libcall.  In that case, cse could not have
4068    managed to substitute the source for the dest later on,
4069    so we can assume the libcall is dead.
4070
4071    PBI is the block info giving pseudoregs live before this insn.
4072    NOTE is the REG_RETVAL note of the insn.  */
4073
4074 static int
4075 libcall_dead_p (pbi, note, insn)
4076      struct propagate_block_info *pbi;
4077      rtx note;
4078      rtx insn;
4079 {
4080   rtx x = single_set (insn);
4081
4082   if (x)
4083     {
4084       register rtx r = SET_SRC (x);
4085       if (GET_CODE (r) == REG)
4086         {
4087           rtx call = XEXP (note, 0);
4088           rtx call_pat;
4089           register int i;
4090
4091           /* Find the call insn.  */
4092           while (call != insn && GET_CODE (call) != CALL_INSN)
4093             call = NEXT_INSN (call);
4094
4095           /* If there is none, do nothing special,
4096              since ordinary death handling can understand these insns.  */
4097           if (call == insn)
4098             return 0;
4099
4100           /* See if the hard reg holding the value is dead.
4101              If this is a PARALLEL, find the call within it.  */
4102           call_pat = PATTERN (call);
4103           if (GET_CODE (call_pat) == PARALLEL)
4104             {
4105               for (i = XVECLEN (call_pat, 0) - 1; i >= 0; i--)
4106                 if (GET_CODE (XVECEXP (call_pat, 0, i)) == SET
4107                     && GET_CODE (SET_SRC (XVECEXP (call_pat, 0, i))) == CALL)
4108                   break;
4109
4110               /* This may be a library call that is returning a value
4111                  via invisible pointer.  Do nothing special, since
4112                  ordinary death handling can understand these insns.  */
4113               if (i < 0)
4114                 return 0;
4115
4116               call_pat = XVECEXP (call_pat, 0, i);
4117             }
4118
4119           return insn_dead_p (pbi, call_pat, 1, REG_NOTES (call));
4120         }
4121     }
4122   return 1;
4123 }
4124
4125 /* Return 1 if register REGNO was used before it was set, i.e. if it is
4126    live at function entry.  Don't count global register variables, variables
4127    in registers that can be used for function arg passing, or variables in
4128    fixed hard registers.  */
4129
4130 int
4131 regno_uninitialized (regno)
4132      int regno;
4133 {
4134   if (n_basic_blocks == 0
4135       || (regno < FIRST_PSEUDO_REGISTER
4136           && (global_regs[regno]
4137               || fixed_regs[regno]
4138               || FUNCTION_ARG_REGNO_P (regno))))
4139     return 0;
4140
4141   return REGNO_REG_SET_P (BASIC_BLOCK (0)->global_live_at_start, regno);
4142 }
4143
4144 /* 1 if register REGNO was alive at a place where `setjmp' was called
4145    and was set more than once or is an argument.
4146    Such regs may be clobbered by `longjmp'.  */
4147
4148 int
4149 regno_clobbered_at_setjmp (regno)
4150      int regno;
4151 {
4152   if (n_basic_blocks == 0)
4153     return 0;
4154
4155   return ((REG_N_SETS (regno) > 1
4156            || REGNO_REG_SET_P (BASIC_BLOCK (0)->global_live_at_start, regno))
4157           && REGNO_REG_SET_P (regs_live_at_setjmp, regno));
4158 }
4159 \f
4160 /* INSN references memory, possibly using autoincrement addressing modes.
4161    Find any entries on the mem_set_list that need to be invalidated due
4162    to an address change.  */
4163
4164 static void
4165 invalidate_mems_from_autoinc (pbi, insn)
4166      struct propagate_block_info *pbi;
4167      rtx insn;
4168 {
4169   rtx note = REG_NOTES (insn);
4170   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
4171     {
4172       if (REG_NOTE_KIND (note) == REG_INC)
4173         {
4174           rtx temp = pbi->mem_set_list;
4175           rtx prev = NULL_RTX;
4176           rtx next;
4177
4178           while (temp)
4179             {
4180               next = XEXP (temp, 1);
4181               if (reg_overlap_mentioned_p (XEXP (note, 0), XEXP (temp, 0)))
4182                 {
4183                   /* Splice temp out of list.  */
4184                   if (prev)
4185                     XEXP (prev, 1) = next;
4186                   else
4187                     pbi->mem_set_list = next;
4188                   free_EXPR_LIST_node (temp);
4189                 }
4190               else
4191                 prev = temp;
4192               temp = next;
4193             }
4194         }
4195     }
4196 }
4197
4198 /* Process the registers that are set within X.  Their bits are set to
4199    1 in the regset DEAD, because they are dead prior to this insn.
4200
4201    If INSN is nonzero, it is the insn being processed.
4202
4203    FLAGS is the set of operations to perform.  */
4204
4205 static void
4206 mark_set_regs (pbi, x, insn)
4207      struct propagate_block_info *pbi;
4208      rtx x, insn;
4209 {
4210   rtx cond = NULL_RTX;
4211   rtx link;
4212   enum rtx_code code;
4213
4214   if (insn)
4215     for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
4216       {
4217         if (REG_NOTE_KIND (link) == REG_INC)
4218           mark_set_1 (pbi, SET, XEXP (link, 0),
4219                       (GET_CODE (x) == COND_EXEC
4220                        ? COND_EXEC_TEST (x) : NULL_RTX),
4221                       insn, pbi->flags);
4222       }
4223  retry:
4224   switch (code = GET_CODE (x))
4225     {
4226     case SET:
4227     case CLOBBER:
4228       mark_set_1 (pbi, code, SET_DEST (x), cond, insn, pbi->flags);
4229       return;
4230
4231     case COND_EXEC:
4232       cond = COND_EXEC_TEST (x);
4233       x = COND_EXEC_CODE (x);
4234       goto retry;
4235
4236     case PARALLEL:
4237       {
4238         register int i;
4239         for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
4240           {
4241             rtx sub = XVECEXP (x, 0, i);
4242             switch (code = GET_CODE (sub))
4243               {
4244               case COND_EXEC:
4245                 if (cond != NULL_RTX)
4246                   abort ();
4247
4248                 cond = COND_EXEC_TEST (sub);
4249                 sub = COND_EXEC_CODE (sub);
4250                 if (GET_CODE (sub) != SET && GET_CODE (sub) != CLOBBER)
4251                   break;
4252                 /* Fall through.  */
4253
4254               case SET:
4255               case CLOBBER:
4256                 mark_set_1 (pbi, code, SET_DEST (sub), cond, insn, pbi->flags);
4257                 break;
4258
4259               default:
4260                 break;
4261               }
4262           }
4263         break;
4264       }
4265
4266     default:
4267       break;
4268     }
4269 }
4270
4271 /* Process a single SET rtx, X.  */
4272
4273 static void
4274 mark_set_1 (pbi, code, reg, cond, insn, flags)
4275      struct propagate_block_info *pbi;
4276      enum rtx_code code;
4277      rtx reg, cond, insn;
4278      int flags;
4279 {
4280   int regno_first = -1, regno_last = -1;
4281   int not_dead = 0;
4282   int i;
4283
4284   /* Some targets place small structures in registers for
4285      return values of functions.  We have to detect this
4286      case specially here to get correct flow information.  */
4287   if (GET_CODE (reg) == PARALLEL
4288       && GET_MODE (reg) == BLKmode)
4289     {
4290       for (i = XVECLEN (reg, 0) - 1; i >= 0; i--)
4291         mark_set_1 (pbi, code, XVECEXP (reg, 0, i), cond, insn, flags);
4292       return;
4293     }
4294
4295   /* Modifying just one hardware register of a multi-reg value or just a
4296      byte field of a register does not mean the value from before this insn
4297      is now dead.  Of course, if it was dead after it's unused now.  */
4298
4299   switch (GET_CODE (reg))
4300     {
4301     case ZERO_EXTRACT:
4302     case SIGN_EXTRACT:
4303     case STRICT_LOW_PART:
4304       /* ??? Assumes STRICT_LOW_PART not used on multi-word registers.  */
4305       do
4306         reg = XEXP (reg, 0);
4307       while (GET_CODE (reg) == SUBREG
4308              || GET_CODE (reg) == ZERO_EXTRACT
4309              || GET_CODE (reg) == SIGN_EXTRACT
4310              || GET_CODE (reg) == STRICT_LOW_PART);
4311       if (GET_CODE (reg) == MEM)
4312         break;
4313       not_dead = REGNO_REG_SET_P (pbi->reg_live, REGNO (reg));
4314       /* Fall through.  */
4315
4316     case REG:
4317       regno_last = regno_first = REGNO (reg);
4318       if (regno_first < FIRST_PSEUDO_REGISTER)
4319         regno_last += HARD_REGNO_NREGS (regno_first, GET_MODE (reg)) - 1;
4320       break;
4321
4322     case SUBREG:
4323       if (GET_CODE (SUBREG_REG (reg)) == REG)
4324         {
4325           enum machine_mode outer_mode = GET_MODE (reg);
4326           enum machine_mode inner_mode = GET_MODE (SUBREG_REG (reg));
4327
4328           /* Identify the range of registers affected.  This is moderately
4329              tricky for hard registers.  See alter_subreg.  */
4330
4331           regno_last = regno_first = REGNO (SUBREG_REG (reg));
4332           if (regno_first < FIRST_PSEUDO_REGISTER)
4333             {
4334 #ifdef ALTER_HARD_SUBREG
4335               regno_first = ALTER_HARD_SUBREG (outer_mode, SUBREG_WORD (reg),
4336                                                inner_mode, regno_first);
4337 #else
4338               regno_first += SUBREG_WORD (reg);
4339 #endif
4340               regno_last = (regno_first
4341                             + HARD_REGNO_NREGS (regno_first, outer_mode) - 1);
4342
4343               /* Since we've just adjusted the register number ranges, make
4344                  sure REG matches.  Otherwise some_was_live will be clear
4345                  when it shouldn't have been, and we'll create incorrect
4346                  REG_UNUSED notes.  */
4347               reg = gen_rtx_REG (outer_mode, regno_first);
4348             }
4349           else
4350             {
4351               /* If the number of words in the subreg is less than the number
4352                  of words in the full register, we have a well-defined partial
4353                  set.  Otherwise the high bits are undefined.
4354
4355                  This is only really applicable to pseudos, since we just took
4356                  care of multi-word hard registers.  */
4357               if (((GET_MODE_SIZE (outer_mode)
4358                     + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
4359                   < ((GET_MODE_SIZE (inner_mode)
4360                       + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
4361                 not_dead = REGNO_REG_SET_P (pbi->reg_live, regno_first);
4362
4363               reg = SUBREG_REG (reg);
4364             }
4365         }
4366       else
4367         reg = SUBREG_REG (reg);
4368       break;
4369
4370     default:
4371       break;
4372     }
4373
4374   /* If this set is a MEM, then it kills any aliased writes.
4375      If this set is a REG, then it kills any MEMs which use the reg.  */
4376   if (optimize && (flags & PROP_SCAN_DEAD_CODE))
4377     {
4378       if (GET_CODE (reg) == MEM || GET_CODE (reg) == REG)
4379         {
4380           rtx temp = pbi->mem_set_list;
4381           rtx prev = NULL_RTX;
4382           rtx next;
4383
4384           while (temp)
4385             {
4386               next = XEXP (temp, 1);
4387               if ((GET_CODE (reg) == MEM
4388                    && output_dependence (XEXP (temp, 0), reg))
4389                   || (GET_CODE (reg) == REG
4390                       && reg_overlap_mentioned_p (reg, XEXP (temp, 0))))
4391                 {
4392                   /* Splice this entry out of the list.  */
4393                   if (prev)
4394                     XEXP (prev, 1) = next;
4395                   else
4396                     pbi->mem_set_list = next;
4397                   free_EXPR_LIST_node (temp);
4398                 }
4399               else
4400                 prev = temp;
4401               temp = next;
4402             }
4403         }
4404
4405       /* If the memory reference had embedded side effects (autoincrement
4406          address modes.  Then we may need to kill some entries on the
4407          memory set list.  */
4408       if (insn && GET_CODE (reg) == MEM)
4409         invalidate_mems_from_autoinc (pbi, insn);
4410
4411       if (GET_CODE (reg) == MEM && ! side_effects_p (reg)
4412           /* ??? With more effort we could track conditional memory life.  */
4413           && ! cond
4414           /* We do not know the size of a BLKmode store, so we do not track
4415              them for redundant store elimination.  */
4416           && GET_MODE (reg) != BLKmode
4417           /* There are no REG_INC notes for SP, so we can't assume we'll see
4418              everything that invalidates it.  To be safe, don't eliminate any
4419              stores though SP; none of them should be redundant anyway.  */
4420           && ! reg_mentioned_p (stack_pointer_rtx, reg))
4421         pbi->mem_set_list = alloc_EXPR_LIST (0, reg, pbi->mem_set_list);
4422     }
4423
4424   if (GET_CODE (reg) == REG
4425       && ! (regno_first == FRAME_POINTER_REGNUM
4426             && (! reload_completed || frame_pointer_needed))
4427 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
4428       && ! (regno_first == HARD_FRAME_POINTER_REGNUM
4429             && (! reload_completed || frame_pointer_needed))
4430 #endif
4431 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4432       && ! (regno_first == ARG_POINTER_REGNUM && fixed_regs[regno_first])
4433 #endif
4434       )
4435     {
4436       int some_was_live = 0, some_was_dead = 0;
4437
4438       for (i = regno_first; i <= regno_last; ++i)
4439         {
4440           int needed_regno = REGNO_REG_SET_P (pbi->reg_live, i);
4441           if (pbi->local_set)
4442             SET_REGNO_REG_SET (pbi->local_set, i);
4443           if (code != CLOBBER)
4444             SET_REGNO_REG_SET (pbi->new_set, i);
4445
4446           some_was_live |= needed_regno;
4447           some_was_dead |= ! needed_regno;
4448         }
4449
4450 #ifdef HAVE_conditional_execution
4451       /* Consider conditional death in deciding that the register needs
4452          a death note.  */
4453       if (some_was_live && ! not_dead
4454           /* The stack pointer is never dead.  Well, not strictly true,
4455              but it's very difficult to tell from here.  Hopefully
4456              combine_stack_adjustments will fix up the most egregious
4457              errors.  */
4458           && regno_first != STACK_POINTER_REGNUM)
4459         {
4460           for (i = regno_first; i <= regno_last; ++i)
4461             if (! mark_regno_cond_dead (pbi, i, cond))
4462               not_dead = 1;
4463         }
4464 #endif
4465
4466       /* Additional data to record if this is the final pass.  */
4467       if (flags & (PROP_LOG_LINKS | PROP_REG_INFO
4468                    | PROP_DEATH_NOTES | PROP_AUTOINC))
4469         {
4470           register rtx y;
4471           register int blocknum = pbi->bb->index;
4472
4473           y = NULL_RTX;
4474           if (flags & (PROP_LOG_LINKS | PROP_AUTOINC))
4475             {
4476               y = pbi->reg_next_use[regno_first];
4477
4478               /* The next use is no longer next, since a store intervenes.  */
4479               for (i = regno_first; i <= regno_last; ++i)
4480                 pbi->reg_next_use[i] = 0;
4481             }
4482
4483           if (flags & PROP_REG_INFO)
4484             {
4485               for (i = regno_first; i <= regno_last; ++i)
4486                 {
4487                   /* Count (weighted) references, stores, etc.  This counts a
4488                      register twice if it is modified, but that is correct.  */
4489                   REG_N_SETS (i) += 1;
4490                   REG_N_REFS (i) += (optimize_size ? 1
4491                                      : pbi->bb->loop_depth + 1);
4492
4493                   /* The insns where a reg is live are normally counted
4494                      elsewhere, but we want the count to include the insn
4495                      where the reg is set, and the normal counting mechanism
4496                      would not count it.  */
4497                   REG_LIVE_LENGTH (i) += 1;
4498                 }
4499
4500               /* If this is a hard reg, record this function uses the reg.  */
4501               if (regno_first < FIRST_PSEUDO_REGISTER)
4502                 {
4503                   for (i = regno_first; i <= regno_last; i++)
4504                     regs_ever_live[i] = 1;
4505                 }
4506               else
4507                 {
4508                   /* Keep track of which basic blocks each reg appears in.  */
4509                   if (REG_BASIC_BLOCK (regno_first) == REG_BLOCK_UNKNOWN)
4510                     REG_BASIC_BLOCK (regno_first) = blocknum;
4511                   else if (REG_BASIC_BLOCK (regno_first) != blocknum)
4512                     REG_BASIC_BLOCK (regno_first) = REG_BLOCK_GLOBAL;
4513                 }
4514             }
4515
4516           if (! some_was_dead)
4517             {
4518               if (flags & PROP_LOG_LINKS)
4519                 {
4520                   /* Make a logical link from the next following insn
4521                      that uses this register, back to this insn.
4522                      The following insns have already been processed.
4523
4524                      We don't build a LOG_LINK for hard registers containing
4525                      in ASM_OPERANDs.  If these registers get replaced,
4526                      we might wind up changing the semantics of the insn,
4527                      even if reload can make what appear to be valid
4528                      assignments later.  */
4529                   if (y && (BLOCK_NUM (y) == blocknum)
4530                       && (regno_first >= FIRST_PSEUDO_REGISTER
4531                           || asm_noperands (PATTERN (y)) < 0))
4532                     LOG_LINKS (y) = alloc_INSN_LIST (insn, LOG_LINKS (y));
4533                 }
4534             }
4535           else if (not_dead)
4536             ;
4537           else if (! some_was_live)
4538             {
4539               if (flags & PROP_REG_INFO)
4540                 REG_N_DEATHS (regno_first) += 1;
4541
4542               if (flags & PROP_DEATH_NOTES)
4543                 {
4544                   /* Note that dead stores have already been deleted
4545                      when possible.  If we get here, we have found a
4546                      dead store that cannot be eliminated (because the
4547                      same insn does something useful).  Indicate this
4548                      by marking the reg being set as dying here.  */
4549                   REG_NOTES (insn)
4550                     = alloc_EXPR_LIST (REG_UNUSED, reg, REG_NOTES (insn));
4551                 }
4552             }
4553           else
4554             {
4555               if (flags & PROP_DEATH_NOTES)
4556                 {
4557                   /* This is a case where we have a multi-word hard register
4558                      and some, but not all, of the words of the register are
4559                      needed in subsequent insns.  Write REG_UNUSED notes
4560                      for those parts that were not needed.  This case should
4561                      be rare.  */
4562
4563                   for (i = regno_first; i <= regno_last; ++i)
4564                     if (! REGNO_REG_SET_P (pbi->reg_live, i))
4565                       REG_NOTES (insn)
4566                         = alloc_EXPR_LIST (REG_UNUSED,
4567                                            gen_rtx_REG (reg_raw_mode[i], i),
4568                                            REG_NOTES (insn));
4569                 }
4570             }
4571         }
4572
4573       /* Mark the register as being dead.  */
4574       if (some_was_live
4575           && ! not_dead
4576           /* The stack pointer is never dead.  Well, not strictly true,
4577              but it's very difficult to tell from here.  Hopefully
4578              combine_stack_adjustments will fix up the most egregious
4579              errors.  */
4580           && regno_first != STACK_POINTER_REGNUM)
4581         {
4582           for (i = regno_first; i <= regno_last; ++i)
4583             CLEAR_REGNO_REG_SET (pbi->reg_live, i);
4584         }
4585     }
4586   else if (GET_CODE (reg) == REG)
4587     {
4588       if (flags & (PROP_LOG_LINKS | PROP_AUTOINC))
4589         pbi->reg_next_use[regno_first] = 0;
4590     }
4591
4592   /* If this is the last pass and this is a SCRATCH, show it will be dying
4593      here and count it.  */
4594   else if (GET_CODE (reg) == SCRATCH)
4595     {
4596       if (flags & PROP_DEATH_NOTES)
4597         REG_NOTES (insn)
4598           = alloc_EXPR_LIST (REG_UNUSED, reg, REG_NOTES (insn));
4599     }
4600 }
4601 \f
4602 #ifdef HAVE_conditional_execution
4603 /* Mark REGNO conditionally dead.
4604    Return true if the register is now unconditionally dead.  */
4605
4606 static int
4607 mark_regno_cond_dead (pbi, regno, cond)
4608      struct propagate_block_info *pbi;
4609      int regno;
4610      rtx cond;
4611 {
4612   /* If this is a store to a predicate register, the value of the
4613      predicate is changing, we don't know that the predicate as seen
4614      before is the same as that seen after.  Flush all dependent
4615      conditions from reg_cond_dead.  This will make all such
4616      conditionally live registers unconditionally live.  */
4617   if (REGNO_REG_SET_P (pbi->reg_cond_reg, regno))
4618     flush_reg_cond_reg (pbi, regno);
4619
4620   /* If this is an unconditional store, remove any conditional
4621      life that may have existed.  */
4622   if (cond == NULL_RTX)
4623     splay_tree_remove (pbi->reg_cond_dead, regno);
4624   else
4625     {
4626       splay_tree_node node;
4627       struct reg_cond_life_info *rcli;
4628       rtx ncond;
4629
4630       /* Otherwise this is a conditional set.  Record that fact.
4631          It may have been conditionally used, or there may be a
4632          subsequent set with a complimentary condition.  */
4633
4634       node = splay_tree_lookup (pbi->reg_cond_dead, regno);
4635       if (node == NULL)
4636         {
4637           /* The register was unconditionally live previously.
4638              Record the current condition as the condition under
4639              which it is dead.  */
4640           rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
4641           rcli->condition = alloc_EXPR_LIST (0, cond, NULL_RTX);
4642           splay_tree_insert (pbi->reg_cond_dead, regno,
4643                              (splay_tree_value) rcli);
4644
4645           SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
4646
4647           /* Not unconditionaly dead.  */
4648           return 0;
4649         }
4650       else
4651         {
4652           /* The register was conditionally live previously.
4653              Add the new condition to the old.  */
4654           rcli = (struct reg_cond_life_info *) node->value;
4655           ncond = rcli->condition;
4656           ncond = ior_reg_cond (ncond, cond);
4657
4658           /* If the register is now unconditionally dead,
4659              remove the entry in the splay_tree.  */
4660           if (ncond == const1_rtx)
4661             splay_tree_remove (pbi->reg_cond_dead, regno);
4662           else
4663             {
4664               rcli->condition = ncond;
4665
4666               SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
4667
4668               /* Not unconditionaly dead.  */
4669               return 0;
4670             }
4671         }
4672     }
4673
4674   return 1;
4675 }
4676
4677 /* Called from splay_tree_delete for pbi->reg_cond_life.  */
4678
4679 static void
4680 free_reg_cond_life_info (value)
4681      splay_tree_value value;
4682 {
4683   struct reg_cond_life_info *rcli = (struct reg_cond_life_info *) value;
4684   free_EXPR_LIST_list (&rcli->condition);
4685   free (rcli);
4686 }
4687
4688 /* Helper function for flush_reg_cond_reg.  */
4689
4690 static int
4691 flush_reg_cond_reg_1 (node, data)
4692      splay_tree_node node;
4693      void *data;
4694 {
4695   struct reg_cond_life_info *rcli;
4696   int *xdata = (int *) data;
4697   unsigned int regno = xdata[0];
4698   rtx c, *prev;
4699
4700   /* Don't need to search if last flushed value was farther on in
4701      the in-order traversal.  */
4702   if (xdata[1] >= (int) node->key)
4703     return 0;
4704
4705   /* Splice out portions of the expression that refer to regno.  */
4706   rcli = (struct reg_cond_life_info *) node->value;
4707   c = *(prev = &rcli->condition);
4708   while (c)
4709     {
4710       if (regno == REGNO (XEXP (XEXP (c, 0), 0)))
4711         {
4712           rtx next = XEXP (c, 1);
4713           free_EXPR_LIST_node (c);
4714           c = *prev = next;
4715         }
4716       else
4717         c = *(prev = &XEXP (c, 1));
4718     }
4719
4720   /* If the entire condition is now NULL, signal the node to be removed.  */
4721   if (! rcli->condition)
4722     {
4723       xdata[1] = node->key;
4724       return -1;
4725     }
4726   else
4727     return 0;
4728 }
4729
4730 /* Flush all (sub) expressions referring to REGNO from REG_COND_LIVE.  */
4731
4732 static void
4733 flush_reg_cond_reg (pbi, regno)
4734      struct propagate_block_info *pbi;
4735      int regno;
4736 {
4737   int pair[2];
4738
4739   pair[0] = regno;
4740   pair[1] = -1;
4741   while (splay_tree_foreach (pbi->reg_cond_dead,
4742                              flush_reg_cond_reg_1, pair) == -1)
4743     splay_tree_remove (pbi->reg_cond_dead, pair[1]);
4744
4745   CLEAR_REGNO_REG_SET (pbi->reg_cond_reg, regno);
4746 }
4747
4748 /* Logical arithmetic on predicate conditions.  IOR, NOT and NAND.
4749    We actually use EXPR_LIST to chain the sub-expressions together
4750    instead of IOR because it's easier to manipulate and we have
4751    the lists.c functions to reuse nodes.
4752
4753    Return a new rtl expression as appropriate.  */
4754
4755 static rtx
4756 ior_reg_cond (old, x)
4757      rtx old, x;
4758 {
4759   enum rtx_code x_code;
4760   rtx x_reg;
4761   rtx c;
4762
4763   /* We expect these conditions to be of the form (eq reg 0).  */
4764   x_code = GET_CODE (x);
4765   if (GET_RTX_CLASS (x_code) != '<'
4766       || GET_CODE (x_reg = XEXP (x, 0)) != REG
4767       || XEXP (x, 1) != const0_rtx)
4768     abort ();
4769
4770   /* Search the expression for an existing sub-expression of X_REG.  */
4771   for (c = old; c; c = XEXP (c, 1))
4772     {
4773       rtx y = XEXP (c, 0);
4774       if (REGNO (XEXP (y, 0)) == REGNO (x_reg))
4775         {
4776           /* If we find X already present in OLD, we need do nothing.  */
4777           if (GET_CODE (y) == x_code)
4778             return old;
4779
4780           /* If we find X being a compliment of a condition in OLD,
4781              then the entire condition is true.  */
4782           if (GET_CODE (y) == reverse_condition (x_code))
4783             return const1_rtx;
4784         }
4785     }
4786
4787   /* Otherwise just add to the chain.  */
4788   return alloc_EXPR_LIST (0, x, old);
4789 }
4790
4791 static rtx
4792 not_reg_cond (x)
4793      rtx x;
4794 {
4795   enum rtx_code x_code;
4796   rtx x_reg;
4797
4798   /* We expect these conditions to be of the form (eq reg 0).  */
4799   x_code = GET_CODE (x);
4800   if (GET_RTX_CLASS (x_code) != '<'
4801       || GET_CODE (x_reg = XEXP (x, 0)) != REG
4802       || XEXP (x, 1) != const0_rtx)
4803     abort ();
4804
4805   return alloc_EXPR_LIST (0, gen_rtx_fmt_ee (reverse_condition (x_code),
4806                                              VOIDmode, x_reg, const0_rtx),
4807                           NULL_RTX);
4808 }
4809
4810 static rtx
4811 nand_reg_cond (old, x)
4812      rtx old, x;
4813 {
4814   enum rtx_code x_code;
4815   rtx x_reg;
4816   rtx c, *prev;
4817
4818   /* We expect these conditions to be of the form (eq reg 0).  */
4819   x_code = GET_CODE (x);
4820   if (GET_RTX_CLASS (x_code) != '<'
4821       || GET_CODE (x_reg = XEXP (x, 0)) != REG
4822       || XEXP (x, 1) != const0_rtx)
4823     abort ();
4824
4825   /* Search the expression for an existing sub-expression of X_REG.  */
4826
4827   for (c = *(prev = &old); c; c = *(prev = &XEXP (c, 1)))
4828     {
4829       rtx y = XEXP (c, 0);
4830       if (REGNO (XEXP (y, 0)) == REGNO (x_reg))
4831         {
4832           /* If we find X already present in OLD, then we need to
4833              splice it out.  */
4834           if (GET_CODE (y) == x_code)
4835             {
4836               *prev = XEXP (c, 1);
4837               free_EXPR_LIST_node (c);
4838               return old ? old : const0_rtx;
4839             }
4840
4841           /* If we find X being a compliment of a condition in OLD,
4842              then we need do nothing.  */
4843           if (GET_CODE (y) == reverse_condition (x_code))
4844             return old;
4845         }
4846     }
4847
4848   /* Otherwise, by implication, the register in question is now live for
4849      the inverse of the condition X.  */
4850   return alloc_EXPR_LIST (0, gen_rtx_fmt_ee (reverse_condition (x_code),
4851                                              VOIDmode, x_reg, const0_rtx),
4852                           old);
4853 }
4854 #endif /* HAVE_conditional_execution */
4855 \f
4856 #ifdef AUTO_INC_DEC
4857
4858 /* Try to substitute the auto-inc expression INC as the address inside
4859    MEM which occurs in INSN.  Currently, the address of MEM is an expression
4860    involving INCR_REG, and INCR is the next use of INCR_REG; it is an insn
4861    that has a single set whose source is a PLUS of INCR_REG and something
4862    else.  */
4863
4864 static void
4865 attempt_auto_inc (pbi, inc, insn, mem, incr, incr_reg)
4866      struct propagate_block_info *pbi;
4867      rtx inc, insn, mem, incr, incr_reg;
4868 {
4869   int regno = REGNO (incr_reg);
4870   rtx set = single_set (incr);
4871   rtx q = SET_DEST (set);
4872   rtx y = SET_SRC (set);
4873   int opnum = XEXP (y, 0) == incr_reg ? 0 : 1;
4874
4875   /* Make sure this reg appears only once in this insn.  */
4876   if (count_occurrences (PATTERN (insn), incr_reg, 1) != 1)
4877     return;
4878
4879   if (dead_or_set_p (incr, incr_reg)
4880       /* Mustn't autoinc an eliminable register.  */
4881       && (regno >= FIRST_PSEUDO_REGISTER
4882           || ! TEST_HARD_REG_BIT (elim_reg_set, regno)))
4883     {
4884       /* This is the simple case.  Try to make the auto-inc.  If
4885          we can't, we are done.  Otherwise, we will do any
4886          needed updates below.  */
4887       if (! validate_change (insn, &XEXP (mem, 0), inc, 0))
4888         return;
4889     }
4890   else if (GET_CODE (q) == REG
4891            /* PREV_INSN used here to check the semi-open interval
4892               [insn,incr).  */
4893            && ! reg_used_between_p (q,  PREV_INSN (insn), incr)
4894            /* We must also check for sets of q as q may be
4895               a call clobbered hard register and there may
4896               be a call between PREV_INSN (insn) and incr.  */
4897            && ! reg_set_between_p (q,  PREV_INSN (insn), incr))
4898     {
4899       /* We have *p followed sometime later by q = p+size.
4900          Both p and q must be live afterward,
4901          and q is not used between INSN and its assignment.
4902          Change it to q = p, ...*q..., q = q+size.
4903          Then fall into the usual case.  */
4904       rtx insns, temp;
4905
4906       start_sequence ();
4907       emit_move_insn (q, incr_reg);
4908       insns = get_insns ();
4909       end_sequence ();
4910
4911       if (basic_block_for_insn)
4912         for (temp = insns; temp; temp = NEXT_INSN (temp))
4913           set_block_for_insn (temp, pbi->bb);
4914
4915       /* If we can't make the auto-inc, or can't make the
4916          replacement into Y, exit.  There's no point in making
4917          the change below if we can't do the auto-inc and doing
4918          so is not correct in the pre-inc case.  */
4919
4920       XEXP (inc, 0) = q;
4921       validate_change (insn, &XEXP (mem, 0), inc, 1);
4922       validate_change (incr, &XEXP (y, opnum), q, 1);
4923       if (! apply_change_group ())
4924         return;
4925
4926       /* We now know we'll be doing this change, so emit the
4927          new insn(s) and do the updates.  */
4928       emit_insns_before (insns, insn);
4929
4930       if (pbi->bb->head == insn)
4931         pbi->bb->head = insns;
4932
4933       /* INCR will become a NOTE and INSN won't contain a
4934          use of INCR_REG.  If a use of INCR_REG was just placed in
4935          the insn before INSN, make that the next use.
4936          Otherwise, invalidate it.  */
4937       if (GET_CODE (PREV_INSN (insn)) == INSN
4938           && GET_CODE (PATTERN (PREV_INSN (insn))) == SET
4939           && SET_SRC (PATTERN (PREV_INSN (insn))) == incr_reg)
4940         pbi->reg_next_use[regno] = PREV_INSN (insn);
4941       else
4942         pbi->reg_next_use[regno] = 0;
4943
4944       incr_reg = q;
4945       regno = REGNO (q);
4946
4947       /* REGNO is now used in INCR which is below INSN, but
4948          it previously wasn't live here.  If we don't mark
4949          it as live, we'll put a REG_DEAD note for it
4950          on this insn, which is incorrect.  */
4951       SET_REGNO_REG_SET (pbi->reg_live, regno);
4952
4953       /* If there are any calls between INSN and INCR, show
4954          that REGNO now crosses them.  */
4955       for (temp = insn; temp != incr; temp = NEXT_INSN (temp))
4956         if (GET_CODE (temp) == CALL_INSN)
4957           REG_N_CALLS_CROSSED (regno)++;
4958     }
4959   else
4960     return;
4961
4962   /* If we haven't returned, it means we were able to make the
4963      auto-inc, so update the status.  First, record that this insn
4964      has an implicit side effect.  */
4965
4966   REG_NOTES (insn) = alloc_EXPR_LIST (REG_INC, incr_reg, REG_NOTES (insn));
4967
4968   /* Modify the old increment-insn to simply copy
4969      the already-incremented value of our register.  */
4970   if (! validate_change (incr, &SET_SRC (set), incr_reg, 0))
4971     abort ();
4972
4973   /* If that makes it a no-op (copying the register into itself) delete
4974      it so it won't appear to be a "use" and a "set" of this
4975      register.  */
4976   if (REGNO (SET_DEST (set)) == REGNO (incr_reg))
4977     {
4978       /* If the original source was dead, it's dead now.  */
4979       rtx note;
4980
4981       while ((note = find_reg_note (incr, REG_DEAD, NULL_RTX)) != NULL_RTX)
4982         {
4983           remove_note (incr, note);
4984           if (XEXP (note, 0) != incr_reg)
4985             CLEAR_REGNO_REG_SET (pbi->reg_live, REGNO (XEXP (note, 0)));
4986         }
4987
4988       PUT_CODE (incr, NOTE);
4989       NOTE_LINE_NUMBER (incr) = NOTE_INSN_DELETED;
4990       NOTE_SOURCE_FILE (incr) = 0;
4991     }
4992
4993   if (regno >= FIRST_PSEUDO_REGISTER)
4994     {
4995       /* Count an extra reference to the reg.  When a reg is
4996          incremented, spilling it is worse, so we want to make
4997          that less likely.  */
4998       REG_N_REFS (regno) += (optimize_size ? 1 : pbi->bb->loop_depth + 1);
4999
5000       /* Count the increment as a setting of the register,
5001          even though it isn't a SET in rtl.  */
5002       REG_N_SETS (regno)++;
5003     }
5004 }
5005
5006 /* X is a MEM found in INSN.  See if we can convert it into an auto-increment
5007    reference.  */
5008
5009 static void
5010 find_auto_inc (pbi, x, insn)
5011      struct propagate_block_info *pbi;
5012      rtx x;
5013      rtx insn;
5014 {
5015   rtx addr = XEXP (x, 0);
5016   HOST_WIDE_INT offset = 0;
5017   rtx set, y, incr, inc_val;
5018   int regno;
5019   int size = GET_MODE_SIZE (GET_MODE (x));
5020
5021   if (GET_CODE (insn) == JUMP_INSN)
5022     return;
5023
5024   /* Here we detect use of an index register which might be good for
5025      postincrement, postdecrement, preincrement, or predecrement.  */
5026
5027   if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
5028     offset = INTVAL (XEXP (addr, 1)), addr = XEXP (addr, 0);
5029
5030   if (GET_CODE (addr) != REG)
5031     return;
5032
5033   regno = REGNO (addr);
5034
5035   /* Is the next use an increment that might make auto-increment? */
5036   incr = pbi->reg_next_use[regno];
5037   if (incr == 0 || BLOCK_NUM (incr) != BLOCK_NUM (insn))
5038     return;
5039   set = single_set (incr);
5040   if (set == 0 || GET_CODE (set) != SET)
5041     return;
5042   y = SET_SRC (set);
5043
5044   if (GET_CODE (y) != PLUS)
5045     return;
5046
5047   if (REG_P (XEXP (y, 0)) && REGNO (XEXP (y, 0)) == REGNO (addr))
5048     inc_val = XEXP (y, 1);
5049   else if (REG_P (XEXP (y, 1)) && REGNO (XEXP (y, 1)) == REGNO (addr))
5050     inc_val = XEXP (y, 0);
5051   else
5052     return;
5053
5054   if (GET_CODE (inc_val) == CONST_INT)
5055     {
5056       if (HAVE_POST_INCREMENT
5057           && (INTVAL (inc_val) == size && offset == 0))
5058         attempt_auto_inc (pbi, gen_rtx_POST_INC (Pmode, addr), insn, x,
5059                           incr, addr);
5060       else if (HAVE_POST_DECREMENT
5061                && (INTVAL (inc_val) == -size && offset == 0))
5062         attempt_auto_inc (pbi, gen_rtx_POST_DEC (Pmode, addr), insn, x,
5063                           incr, addr);
5064       else if (HAVE_PRE_INCREMENT
5065                && (INTVAL (inc_val) == size && offset == size))
5066         attempt_auto_inc (pbi, gen_rtx_PRE_INC (Pmode, addr), insn, x,
5067                           incr, addr);
5068       else if (HAVE_PRE_DECREMENT
5069                && (INTVAL (inc_val) == -size && offset == -size))
5070         attempt_auto_inc (pbi, gen_rtx_PRE_DEC (Pmode, addr), insn, x,
5071                           incr, addr);
5072       else if (HAVE_POST_MODIFY_DISP && offset == 0)
5073         attempt_auto_inc (pbi, gen_rtx_POST_MODIFY (Pmode, addr,
5074                                                     gen_rtx_PLUS (Pmode,
5075                                                                   addr,
5076                                                                   inc_val)),
5077                           insn, x, incr, addr);
5078     }
5079   else if (GET_CODE (inc_val) == REG
5080            && ! reg_set_between_p (inc_val, PREV_INSN (insn),
5081                                    NEXT_INSN (incr)))
5082
5083     {
5084       if (HAVE_POST_MODIFY_REG && offset == 0)
5085         attempt_auto_inc (pbi, gen_rtx_POST_MODIFY (Pmode, addr,
5086                                                     gen_rtx_PLUS (Pmode,
5087                                                                   addr,
5088                                                                   inc_val)),
5089                           insn, x, incr, addr);
5090     }
5091 }
5092
5093 #endif /* AUTO_INC_DEC */
5094 \f
5095 static void
5096 mark_used_reg (pbi, reg, cond, insn)
5097      struct propagate_block_info *pbi;
5098      rtx reg;
5099      rtx cond ATTRIBUTE_UNUSED;
5100      rtx insn;
5101 {
5102   int regno = REGNO (reg);
5103   int some_was_live = REGNO_REG_SET_P (pbi->reg_live, regno);
5104   int some_was_dead = ! some_was_live;
5105   int some_not_set;
5106   int n;
5107
5108   /* A hard reg in a wide mode may really be multiple registers.
5109      If so, mark all of them just like the first.  */
5110   if (regno < FIRST_PSEUDO_REGISTER)
5111     {
5112       n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5113       while (--n > 0)
5114         {
5115           int needed_regno = REGNO_REG_SET_P (pbi->reg_live, regno + n);
5116           some_was_live |= needed_regno;
5117           some_was_dead |= ! needed_regno;
5118         }
5119     }
5120
5121   if (pbi->flags & (PROP_LOG_LINKS | PROP_AUTOINC))
5122     {
5123       /* Record where each reg is used, so when the reg is set we know
5124          the next insn that uses it.  */
5125       pbi->reg_next_use[regno] = insn;
5126     }
5127
5128   if (pbi->flags & PROP_REG_INFO)
5129     {
5130       if (regno < FIRST_PSEUDO_REGISTER)
5131         {
5132           /* If this is a register we are going to try to eliminate,
5133              don't mark it live here.  If we are successful in
5134              eliminating it, it need not be live unless it is used for
5135              pseudos, in which case it will have been set live when it
5136              was allocated to the pseudos.  If the register will not
5137              be eliminated, reload will set it live at that point.
5138
5139              Otherwise, record that this function uses this register.  */
5140           /* ??? The PPC backend tries to "eliminate" on the pic
5141              register to itself.  This should be fixed.  In the mean
5142              time, hack around it.  */
5143
5144           if (! (TEST_HARD_REG_BIT (elim_reg_set, regno)
5145                  && (regno == FRAME_POINTER_REGNUM
5146                      || regno == ARG_POINTER_REGNUM)))
5147             {
5148               int n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5149               do
5150                 regs_ever_live[regno + --n] = 1;
5151               while (n > 0);
5152             }
5153         }
5154       else
5155         {
5156           /* Keep track of which basic block each reg appears in.  */
5157
5158           register int blocknum = pbi->bb->index;
5159           if (REG_BASIC_BLOCK (regno) == REG_BLOCK_UNKNOWN)
5160             REG_BASIC_BLOCK (regno) = blocknum;
5161           else if (REG_BASIC_BLOCK (regno) != blocknum)
5162             REG_BASIC_BLOCK (regno) = REG_BLOCK_GLOBAL;
5163
5164           /* Count (weighted) number of uses of each reg.  */
5165           REG_N_REFS (regno) += (optimize_size ? 1
5166                                  : pbi->bb->loop_depth + 1);
5167         }
5168     }
5169
5170   /* Find out if any of the register was set this insn.  */
5171   some_not_set = ! REGNO_REG_SET_P (pbi->new_set, regno);
5172   if (regno < FIRST_PSEUDO_REGISTER)
5173     {
5174       n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5175       while (--n > 0)
5176         some_not_set |= ! REGNO_REG_SET_P (pbi->new_set, regno + n);
5177     }
5178
5179   /* Record and count the insns in which a reg dies.  If it is used in
5180      this insn and was dead below the insn then it dies in this insn.
5181      If it was set in this insn, we do not make a REG_DEAD note;
5182      likewise if we already made such a note.  */
5183   if ((pbi->flags & (PROP_DEATH_NOTES | PROP_REG_INFO))
5184       && some_was_dead
5185       && some_not_set)
5186     {
5187       /* Check for the case where the register dying partially
5188          overlaps the register set by this insn.  */
5189       if (regno < FIRST_PSEUDO_REGISTER
5190           && HARD_REGNO_NREGS (regno, GET_MODE (reg)) > 1)
5191         {
5192           n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5193           while (--n >= 0)
5194             some_was_live |= REGNO_REG_SET_P (pbi->new_set, regno + n);
5195         }
5196
5197       /* If none of the words in X is needed, make a REG_DEAD note.
5198          Otherwise, we must make partial REG_DEAD notes.  */
5199       if (! some_was_live)
5200         {
5201           if ((pbi->flags & PROP_DEATH_NOTES)
5202               && ! find_regno_note (insn, REG_DEAD, regno))
5203             REG_NOTES (insn)
5204               = alloc_EXPR_LIST (REG_DEAD, reg, REG_NOTES (insn));
5205
5206           if (pbi->flags & PROP_REG_INFO)
5207             REG_N_DEATHS (regno)++;
5208         }
5209       else
5210         {
5211           /* Don't make a REG_DEAD note for a part of a register
5212              that is set in the insn.  */
5213
5214           n = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1;
5215           for (; n >= regno; n--)
5216             if (! REGNO_REG_SET_P (pbi->reg_live, n)
5217                 && ! dead_or_set_regno_p (insn, n))
5218               REG_NOTES (insn)
5219                 = alloc_EXPR_LIST (REG_DEAD,
5220                                    gen_rtx_REG (reg_raw_mode[n], n),
5221                                    REG_NOTES (insn));
5222         }
5223     }
5224
5225   SET_REGNO_REG_SET (pbi->reg_live, regno);
5226   if (regno < FIRST_PSEUDO_REGISTER)
5227     {
5228       n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5229       while (--n > 0)
5230         SET_REGNO_REG_SET (pbi->reg_live, regno + n);
5231     }
5232
5233 #ifdef HAVE_conditional_execution
5234   /* If this is a conditional use, record that fact.  If it is later
5235      conditionally set, we'll know to kill the register.  */
5236   if (cond != NULL_RTX)
5237     {
5238       splay_tree_node node;
5239       struct reg_cond_life_info *rcli;
5240       rtx ncond;
5241
5242       if (some_was_live)
5243         {
5244           node = splay_tree_lookup (pbi->reg_cond_dead, regno);
5245           if (node == NULL)
5246             {
5247               /* The register was unconditionally live previously.
5248                  No need to do anything.  */
5249             }
5250           else
5251             {
5252               /* The register was conditionally live previously.
5253                  Subtract the new life cond from the old death cond.  */
5254               rcli = (struct reg_cond_life_info *) node->value;
5255               ncond = rcli->condition;
5256               ncond = nand_reg_cond (ncond, cond);
5257
5258               /* If the register is now unconditionally live, remove the
5259                  entry in the splay_tree.  */
5260               if (ncond == const0_rtx)
5261                 {
5262                   rcli->condition = NULL_RTX;
5263                   splay_tree_remove (pbi->reg_cond_dead, regno);
5264                 }
5265               else
5266                 {
5267                   rcli->condition = ncond;
5268                   SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
5269                 }
5270             }
5271         }
5272       else
5273         {
5274           /* The register was not previously live at all.  Record
5275              the condition under which it is still dead.  */
5276           rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
5277           rcli->condition = not_reg_cond (cond);
5278           splay_tree_insert (pbi->reg_cond_dead, regno,
5279                              (splay_tree_value) rcli);
5280
5281           SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
5282         }
5283     }
5284   else if (some_was_live)
5285     {
5286       splay_tree_node node;
5287       struct reg_cond_life_info *rcli;
5288
5289       node = splay_tree_lookup (pbi->reg_cond_dead, regno);
5290       if (node != NULL)
5291         {
5292           /* The register was conditionally live previously, but is now
5293              unconditionally so.  Remove it from the conditionally dead
5294              list, so that a conditional set won't cause us to think
5295              it dead.  */
5296           rcli = (struct reg_cond_life_info *) node->value;
5297           rcli->condition = NULL_RTX;
5298           splay_tree_remove (pbi->reg_cond_dead, regno);
5299         }
5300     }
5301
5302 #endif
5303 }
5304
5305 /* Scan expression X and store a 1-bit in NEW_LIVE for each reg it uses.
5306    This is done assuming the registers needed from X are those that
5307    have 1-bits in PBI->REG_LIVE.
5308
5309    INSN is the containing instruction.  If INSN is dead, this function
5310    is not called.  */
5311
5312 static void
5313 mark_used_regs (pbi, x, cond, insn)
5314      struct propagate_block_info *pbi;
5315      rtx x, cond, insn;
5316 {
5317   register RTX_CODE code;
5318   register int regno;
5319   int flags = pbi->flags;
5320
5321  retry:
5322   code = GET_CODE (x);
5323   switch (code)
5324     {
5325     case LABEL_REF:
5326     case SYMBOL_REF:
5327     case CONST_INT:
5328     case CONST:
5329     case CONST_DOUBLE:
5330     case PC:
5331     case ADDR_VEC:
5332     case ADDR_DIFF_VEC:
5333       return;
5334
5335 #ifdef HAVE_cc0
5336     case CC0:
5337       pbi->cc0_live = 1;
5338       return;
5339 #endif
5340
5341     case CLOBBER:
5342       /* If we are clobbering a MEM, mark any registers inside the address
5343          as being used.  */
5344       if (GET_CODE (XEXP (x, 0)) == MEM)
5345         mark_used_regs (pbi, XEXP (XEXP (x, 0), 0), cond, insn);
5346       return;
5347
5348     case MEM:
5349       /* Don't bother watching stores to mems if this is not the
5350          final pass.  We'll not be deleting dead stores this round.  */
5351       if (optimize && (flags & PROP_SCAN_DEAD_CODE))
5352         {
5353           /* Invalidate the data for the last MEM stored, but only if MEM is
5354              something that can be stored into.  */
5355           if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
5356               && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
5357             /* Needn't clear the memory set list.  */
5358             ;
5359           else
5360             {
5361               rtx temp = pbi->mem_set_list;
5362               rtx prev = NULL_RTX;
5363               rtx next;
5364
5365               while (temp)
5366                 {
5367                   next = XEXP (temp, 1);
5368                   if (anti_dependence (XEXP (temp, 0), x))
5369                     {
5370                       /* Splice temp out of the list.  */
5371                       if (prev)
5372                         XEXP (prev, 1) = next;
5373                       else
5374                         pbi->mem_set_list = next;
5375                       free_EXPR_LIST_node (temp);
5376                     }
5377                   else
5378                     prev = temp;
5379                   temp = next;
5380                 }
5381             }
5382
5383           /* If the memory reference had embedded side effects (autoincrement
5384              address modes.  Then we may need to kill some entries on the
5385              memory set list.  */
5386           if (insn)
5387             invalidate_mems_from_autoinc (pbi, insn);
5388         }
5389
5390 #ifdef AUTO_INC_DEC
5391       if (flags & PROP_AUTOINC)
5392         find_auto_inc (pbi, x, insn);
5393 #endif
5394       break;
5395
5396     case SUBREG:
5397 #ifdef CLASS_CANNOT_CHANGE_MODE
5398       if (GET_CODE (SUBREG_REG (x)) == REG
5399           && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER
5400           && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (x),
5401                                          GET_MODE (SUBREG_REG (x))))
5402         REG_CHANGES_MODE (REGNO (SUBREG_REG (x))) = 1;
5403 #endif
5404
5405       /* While we're here, optimize this case.  */
5406       x = SUBREG_REG (x);
5407       if (GET_CODE (x) != REG)
5408         goto retry;
5409       /* Fall through.  */
5410
5411     case REG:
5412       /* See a register other than being set => mark it as needed.  */
5413       mark_used_reg (pbi, x, cond, insn);
5414       return;
5415
5416     case SET:
5417       {
5418         register rtx testreg = SET_DEST (x);
5419         int mark_dest = 0;
5420
5421         /* If storing into MEM, don't show it as being used.  But do
5422            show the address as being used.  */
5423         if (GET_CODE (testreg) == MEM)
5424           {
5425 #ifdef AUTO_INC_DEC
5426             if (flags & PROP_AUTOINC)
5427               find_auto_inc (pbi, testreg, insn);
5428 #endif
5429             mark_used_regs (pbi, XEXP (testreg, 0), cond, insn);
5430             mark_used_regs (pbi, SET_SRC (x), cond, insn);
5431             return;
5432           }
5433
5434         /* Storing in STRICT_LOW_PART is like storing in a reg
5435            in that this SET might be dead, so ignore it in TESTREG.
5436            but in some other ways it is like using the reg.
5437
5438            Storing in a SUBREG or a bit field is like storing the entire
5439            register in that if the register's value is not used
5440            then this SET is not needed.  */
5441         while (GET_CODE (testreg) == STRICT_LOW_PART
5442                || GET_CODE (testreg) == ZERO_EXTRACT
5443                || GET_CODE (testreg) == SIGN_EXTRACT
5444                || GET_CODE (testreg) == SUBREG)
5445           {
5446 #ifdef CLASS_CANNOT_CHANGE_MODE
5447             if (GET_CODE (testreg) == SUBREG
5448                 && GET_CODE (SUBREG_REG (testreg)) == REG
5449                 && REGNO (SUBREG_REG (testreg)) >= FIRST_PSEUDO_REGISTER
5450                 && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (SUBREG_REG (testreg)),
5451                                                GET_MODE (testreg)))
5452               REG_CHANGES_MODE (REGNO (SUBREG_REG (testreg))) = 1;
5453 #endif
5454
5455             /* Modifying a single register in an alternate mode
5456                does not use any of the old value.  But these other
5457                ways of storing in a register do use the old value.  */
5458             if (GET_CODE (testreg) == SUBREG
5459                 && !(REG_SIZE (SUBREG_REG (testreg)) > REG_SIZE (testreg)))
5460               ;
5461             else
5462               mark_dest = 1;
5463
5464             testreg = XEXP (testreg, 0);
5465           }
5466
5467         /* If this is a store into a register, recursively scan the
5468            value being stored.  */
5469
5470         if ((GET_CODE (testreg) == PARALLEL
5471              && GET_MODE (testreg) == BLKmode)
5472             || (GET_CODE (testreg) == REG
5473                 && (regno = REGNO (testreg),
5474                     ! (regno == FRAME_POINTER_REGNUM
5475                        && (! reload_completed || frame_pointer_needed)))
5476 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
5477                 && ! (regno == HARD_FRAME_POINTER_REGNUM
5478                       && (! reload_completed || frame_pointer_needed))
5479 #endif
5480 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
5481                 && ! (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
5482 #endif
5483                 ))
5484           {
5485             if (mark_dest)
5486               mark_used_regs (pbi, SET_DEST (x), cond, insn);
5487             mark_used_regs (pbi, SET_SRC (x), cond, insn);
5488             return;
5489           }
5490       }
5491       break;
5492
5493     case ASM_OPERANDS:
5494     case UNSPEC_VOLATILE:
5495     case TRAP_IF:
5496     case ASM_INPUT:
5497       {
5498         /* Traditional and volatile asm instructions must be considered to use
5499            and clobber all hard registers, all pseudo-registers and all of
5500            memory.  So must TRAP_IF and UNSPEC_VOLATILE operations.
5501
5502            Consider for instance a volatile asm that changes the fpu rounding
5503            mode.  An insn should not be moved across this even if it only uses
5504            pseudo-regs because it might give an incorrectly rounded result.
5505
5506            ?!? Unfortunately, marking all hard registers as live causes massive
5507            problems for the register allocator and marking all pseudos as live
5508            creates mountains of uninitialized variable warnings.
5509
5510            So for now, just clear the memory set list and mark any regs
5511            we can find in ASM_OPERANDS as used.  */
5512         if (code != ASM_OPERANDS || MEM_VOLATILE_P (x))
5513           free_EXPR_LIST_list (&pbi->mem_set_list);
5514
5515         /* For all ASM_OPERANDS, we must traverse the vector of input operands.
5516            We can not just fall through here since then we would be confused
5517            by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
5518            traditional asms unlike their normal usage.  */
5519         if (code == ASM_OPERANDS)
5520           {
5521             int j;
5522
5523             for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
5524               mark_used_regs (pbi, ASM_OPERANDS_INPUT (x, j), cond, insn);
5525           }
5526         break;
5527       }
5528
5529     case COND_EXEC:
5530       if (cond != NULL_RTX)
5531         abort ();
5532
5533       mark_used_regs (pbi, COND_EXEC_TEST (x), NULL_RTX, insn);
5534
5535       cond = COND_EXEC_TEST (x);
5536       x = COND_EXEC_CODE (x);
5537       goto retry;
5538
5539     case PHI:
5540       /* We _do_not_ want to scan operands of phi nodes.  Operands of
5541          a phi function are evaluated only when control reaches this
5542          block along a particular edge.  Therefore, regs that appear
5543          as arguments to phi should not be added to the global live at
5544          start.  */
5545       return;
5546
5547     default:
5548       break;
5549     }
5550
5551   /* Recursively scan the operands of this expression.  */
5552
5553   {
5554     register const char *fmt = GET_RTX_FORMAT (code);
5555     register int i;
5556
5557     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5558       {
5559         if (fmt[i] == 'e')
5560           {
5561             /* Tail recursive case: save a function call level.  */
5562             if (i == 0)
5563               {
5564                 x = XEXP (x, 0);
5565                 goto retry;
5566               }
5567             mark_used_regs (pbi, XEXP (x, i), cond, insn);
5568           }
5569         else if (fmt[i] == 'E')
5570           {
5571             register int j;
5572             for (j = 0; j < XVECLEN (x, i); j++)
5573               mark_used_regs (pbi, XVECEXP (x, i, j), cond, insn);
5574           }
5575       }
5576   }
5577 }
5578 \f
5579 #ifdef AUTO_INC_DEC
5580
5581 static int
5582 try_pre_increment_1 (pbi, insn)
5583      struct propagate_block_info *pbi;
5584      rtx insn;
5585 {
5586   /* Find the next use of this reg.  If in same basic block,
5587      make it do pre-increment or pre-decrement if appropriate.  */
5588   rtx x = single_set (insn);
5589   HOST_WIDE_INT amount = ((GET_CODE (SET_SRC (x)) == PLUS ? 1 : -1)
5590                           * INTVAL (XEXP (SET_SRC (x), 1)));
5591   int regno = REGNO (SET_DEST (x));
5592   rtx y = pbi->reg_next_use[regno];
5593   if (y != 0
5594       && BLOCK_NUM (y) == BLOCK_NUM (insn)
5595       /* Don't do this if the reg dies, or gets set in y; a standard addressing
5596          mode would be better.  */
5597       && ! dead_or_set_p (y, SET_DEST (x))
5598       && try_pre_increment (y, SET_DEST (x), amount))
5599     {
5600       /* We have found a suitable auto-increment
5601          and already changed insn Y to do it.
5602          So flush this increment-instruction.  */
5603       PUT_CODE (insn, NOTE);
5604       NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
5605       NOTE_SOURCE_FILE (insn) = 0;
5606       /* Count a reference to this reg for the increment
5607          insn we are deleting.  When a reg is incremented.
5608          spilling it is worse, so we want to make that
5609          less likely.  */
5610       if (regno >= FIRST_PSEUDO_REGISTER)
5611         {
5612           REG_N_REFS (regno) += (optimize_size ? 1
5613                                  : pbi->bb->loop_depth + 1);
5614           REG_N_SETS (regno)++;
5615         }
5616       return 1;
5617     }
5618   return 0;
5619 }
5620
5621 /* Try to change INSN so that it does pre-increment or pre-decrement
5622    addressing on register REG in order to add AMOUNT to REG.
5623    AMOUNT is negative for pre-decrement.
5624    Returns 1 if the change could be made.
5625    This checks all about the validity of the result of modifying INSN.  */
5626
5627 static int
5628 try_pre_increment (insn, reg, amount)
5629      rtx insn, reg;
5630      HOST_WIDE_INT amount;
5631 {
5632   register rtx use;
5633
5634   /* Nonzero if we can try to make a pre-increment or pre-decrement.
5635      For example, addl $4,r1; movl (r1),... can become movl +(r1),...  */
5636   int pre_ok = 0;
5637   /* Nonzero if we can try to make a post-increment or post-decrement.
5638      For example, addl $4,r1; movl -4(r1),... can become movl (r1)+,...
5639      It is possible for both PRE_OK and POST_OK to be nonzero if the machine
5640      supports both pre-inc and post-inc, or both pre-dec and post-dec.  */
5641   int post_ok = 0;
5642
5643   /* Nonzero if the opportunity actually requires post-inc or post-dec.  */
5644   int do_post = 0;
5645
5646   /* From the sign of increment, see which possibilities are conceivable
5647      on this target machine.  */
5648   if (HAVE_PRE_INCREMENT && amount > 0)
5649     pre_ok = 1;
5650   if (HAVE_POST_INCREMENT && amount > 0)
5651     post_ok = 1;
5652
5653   if (HAVE_PRE_DECREMENT && amount < 0)
5654     pre_ok = 1;
5655   if (HAVE_POST_DECREMENT && amount < 0)
5656     post_ok = 1;
5657
5658   if (! (pre_ok || post_ok))
5659     return 0;
5660
5661   /* It is not safe to add a side effect to a jump insn
5662      because if the incremented register is spilled and must be reloaded
5663      there would be no way to store the incremented value back in memory.  */
5664
5665   if (GET_CODE (insn) == JUMP_INSN)
5666     return 0;
5667
5668   use = 0;
5669   if (pre_ok)
5670     use = find_use_as_address (PATTERN (insn), reg, 0);
5671   if (post_ok && (use == 0 || use == (rtx) 1))
5672     {
5673       use = find_use_as_address (PATTERN (insn), reg, -amount);
5674       do_post = 1;
5675     }
5676
5677   if (use == 0 || use == (rtx) 1)
5678     return 0;
5679
5680   if (GET_MODE_SIZE (GET_MODE (use)) != (amount > 0 ? amount : - amount))
5681     return 0;
5682
5683   /* See if this combination of instruction and addressing mode exists.  */
5684   if (! validate_change (insn, &XEXP (use, 0),
5685                          gen_rtx_fmt_e (amount > 0
5686                                         ? (do_post ? POST_INC : PRE_INC)
5687                                         : (do_post ? POST_DEC : PRE_DEC),
5688                                         Pmode, reg), 0))
5689     return 0;
5690
5691   /* Record that this insn now has an implicit side effect on X.  */
5692   REG_NOTES (insn) = alloc_EXPR_LIST (REG_INC, reg, REG_NOTES (insn));
5693   return 1;
5694 }
5695
5696 #endif /* AUTO_INC_DEC */
5697 \f
5698 /* Find the place in the rtx X where REG is used as a memory address.
5699    Return the MEM rtx that so uses it.
5700    If PLUSCONST is nonzero, search instead for a memory address equivalent to
5701    (plus REG (const_int PLUSCONST)).
5702
5703    If such an address does not appear, return 0.
5704    If REG appears more than once, or is used other than in such an address,
5705    return (rtx)1.  */
5706
5707 rtx
5708 find_use_as_address (x, reg, plusconst)
5709      register rtx x;
5710      rtx reg;
5711      HOST_WIDE_INT plusconst;
5712 {
5713   enum rtx_code code = GET_CODE (x);
5714   const char *fmt = GET_RTX_FORMAT (code);
5715   register int i;
5716   register rtx value = 0;
5717   register rtx tem;
5718
5719   if (code == MEM && XEXP (x, 0) == reg && plusconst == 0)
5720     return x;
5721
5722   if (code == MEM && GET_CODE (XEXP (x, 0)) == PLUS
5723       && XEXP (XEXP (x, 0), 0) == reg
5724       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
5725       && INTVAL (XEXP (XEXP (x, 0), 1)) == plusconst)
5726     return x;
5727
5728   if (code == SIGN_EXTRACT || code == ZERO_EXTRACT)
5729     {
5730       /* If REG occurs inside a MEM used in a bit-field reference,
5731          that is unacceptable.  */
5732       if (find_use_as_address (XEXP (x, 0), reg, 0) != 0)
5733         return (rtx) (HOST_WIDE_INT) 1;
5734     }
5735
5736   if (x == reg)
5737     return (rtx) (HOST_WIDE_INT) 1;
5738
5739   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5740     {
5741       if (fmt[i] == 'e')
5742         {
5743           tem = find_use_as_address (XEXP (x, i), reg, plusconst);
5744           if (value == 0)
5745             value = tem;
5746           else if (tem != 0)
5747             return (rtx) (HOST_WIDE_INT) 1;
5748         }
5749       else if (fmt[i] == 'E')
5750         {
5751           register int j;
5752           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
5753             {
5754               tem = find_use_as_address (XVECEXP (x, i, j), reg, plusconst);
5755               if (value == 0)
5756                 value = tem;
5757               else if (tem != 0)
5758                 return (rtx) (HOST_WIDE_INT) 1;
5759             }
5760         }
5761     }
5762
5763   return value;
5764 }
5765 \f
5766 /* Write information about registers and basic blocks into FILE.
5767    This is part of making a debugging dump.  */
5768
5769 void
5770 dump_regset (r, outf)
5771      regset r;
5772      FILE *outf;
5773 {
5774   int i;
5775   if (r == NULL)
5776     {
5777       fputs (" (nil)", outf);
5778       return;
5779     }
5780
5781   EXECUTE_IF_SET_IN_REG_SET (r, 0, i,
5782     {
5783       fprintf (outf, " %d", i);
5784       if (i < FIRST_PSEUDO_REGISTER)
5785         fprintf (outf, " [%s]",
5786                  reg_names[i]);
5787     });
5788 }
5789
5790 void
5791 debug_regset (r)
5792      regset r;
5793 {
5794   dump_regset (r, stderr);
5795   putc ('\n', stderr);
5796 }
5797
5798 void
5799 dump_flow_info (file)
5800      FILE *file;
5801 {
5802   register int i;
5803   static const char * const reg_class_names[] = REG_CLASS_NAMES;
5804
5805   fprintf (file, "%d registers.\n", max_regno);
5806   for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
5807     if (REG_N_REFS (i))
5808       {
5809         enum reg_class class, altclass;
5810         fprintf (file, "\nRegister %d used %d times across %d insns",
5811                  i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
5812         if (REG_BASIC_BLOCK (i) >= 0)
5813           fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
5814         if (REG_N_SETS (i))
5815           fprintf (file, "; set %d time%s", REG_N_SETS (i),
5816                    (REG_N_SETS (i) == 1) ? "" : "s");
5817         if (REG_USERVAR_P (regno_reg_rtx[i]))
5818           fprintf (file, "; user var");
5819         if (REG_N_DEATHS (i) != 1)
5820           fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
5821         if (REG_N_CALLS_CROSSED (i) == 1)
5822           fprintf (file, "; crosses 1 call");
5823         else if (REG_N_CALLS_CROSSED (i))
5824           fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
5825         if (PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
5826           fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
5827         class = reg_preferred_class (i);
5828         altclass = reg_alternate_class (i);
5829         if (class != GENERAL_REGS || altclass != ALL_REGS)
5830           {
5831             if (altclass == ALL_REGS || class == ALL_REGS)
5832               fprintf (file, "; pref %s", reg_class_names[(int) class]);
5833             else if (altclass == NO_REGS)
5834               fprintf (file, "; %s or none", reg_class_names[(int) class]);
5835             else
5836               fprintf (file, "; pref %s, else %s",
5837                        reg_class_names[(int) class],
5838                        reg_class_names[(int) altclass]);
5839           }
5840         if (REGNO_POINTER_FLAG (i))
5841           fprintf (file, "; pointer");
5842         fprintf (file, ".\n");
5843       }
5844
5845   fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
5846   for (i = 0; i < n_basic_blocks; i++)
5847     {
5848       register basic_block bb = BASIC_BLOCK (i);
5849       register edge e;
5850
5851       fprintf (file, "\nBasic block %d: first insn %d, last %d, loop_depth %d, count %d.\n",
5852                i, INSN_UID (bb->head), INSN_UID (bb->end), bb->loop_depth, bb->count);
5853
5854       fprintf (file, "Predecessors: ");
5855       for (e = bb->pred; e; e = e->pred_next)
5856         dump_edge_info (file, e, 0);
5857
5858       fprintf (file, "\nSuccessors: ");
5859       for (e = bb->succ; e; e = e->succ_next)
5860         dump_edge_info (file, e, 1);
5861
5862       fprintf (file, "\nRegisters live at start:");
5863       dump_regset (bb->global_live_at_start, file);
5864
5865       fprintf (file, "\nRegisters live at end:");
5866       dump_regset (bb->global_live_at_end, file);
5867
5868       putc ('\n', file);
5869     }
5870
5871   putc ('\n', file);
5872 }
5873
5874 void
5875 debug_flow_info ()
5876 {
5877   dump_flow_info (stderr);
5878 }
5879
5880 static void
5881 dump_edge_info (file, e, do_succ)
5882      FILE *file;
5883      edge e;
5884      int do_succ;
5885 {
5886   basic_block side = (do_succ ? e->dest : e->src);
5887
5888   if (side == ENTRY_BLOCK_PTR)
5889     fputs (" ENTRY", file);
5890   else if (side == EXIT_BLOCK_PTR)
5891     fputs (" EXIT", file);
5892   else
5893     fprintf (file, " %d", side->index);
5894
5895   if (e->count)
5896     fprintf (file, " count:%d", e->count);
5897
5898   if (e->flags)
5899     {
5900       static const char * const bitnames[] = {
5901         "fallthru", "crit", "ab", "abcall", "eh", "fake"
5902       };
5903       int comma = 0;
5904       int i, flags = e->flags;
5905
5906       fputc (' ', file);
5907       fputc ('(', file);
5908       for (i = 0; flags; i++)
5909         if (flags & (1 << i))
5910           {
5911             flags &= ~(1 << i);
5912
5913             if (comma)
5914               fputc (',', file);
5915             if (i < (int) ARRAY_SIZE (bitnames))
5916               fputs (bitnames[i], file);
5917             else
5918               fprintf (file, "%d", i);
5919             comma = 1;
5920           }
5921       fputc (')', file);
5922     }
5923 }
5924 \f
5925 /* Print out one basic block with live information at start and end.  */
5926
5927 void
5928 dump_bb (bb, outf)
5929      basic_block bb;
5930      FILE *outf;
5931 {
5932   rtx insn;
5933   rtx last;
5934   edge e;
5935
5936   fprintf (outf, ";; Basic block %d, loop depth %d, count %d",
5937            bb->index, bb->loop_depth, bb->count);
5938   if (bb->eh_beg != -1 || bb->eh_end != -1)
5939     fprintf (outf, ", eh regions %d/%d", bb->eh_beg, bb->eh_end);
5940   putc ('\n', outf);
5941
5942   fputs (";; Predecessors: ", outf);
5943   for (e = bb->pred; e; e = e->pred_next)
5944     dump_edge_info (outf, e, 0);
5945   putc ('\n', outf);
5946
5947   fputs (";; Registers live at start:", outf);
5948   dump_regset (bb->global_live_at_start, outf);
5949   putc ('\n', outf);
5950
5951   for (insn = bb->head, last = NEXT_INSN (bb->end);
5952        insn != last;
5953        insn = NEXT_INSN (insn))
5954     print_rtl_single (outf, insn);
5955
5956   fputs (";; Registers live at end:", outf);
5957   dump_regset (bb->global_live_at_end, outf);
5958   putc ('\n', outf);
5959
5960   fputs (";; Successors: ", outf);
5961   for (e = bb->succ; e; e = e->succ_next)
5962     dump_edge_info (outf, e, 1);
5963   putc ('\n', outf);
5964 }
5965
5966 void
5967 debug_bb (bb)
5968      basic_block bb;
5969 {
5970   dump_bb (bb, stderr);
5971 }
5972
5973 void
5974 debug_bb_n (n)
5975      int n;
5976 {
5977   dump_bb (BASIC_BLOCK (n), stderr);
5978 }
5979
5980 /* Like print_rtl, but also print out live information for the start of each
5981    basic block.  */
5982
5983 void
5984 print_rtl_with_bb (outf, rtx_first)
5985      FILE *outf;
5986      rtx rtx_first;
5987 {
5988   register rtx tmp_rtx;
5989
5990   if (rtx_first == 0)
5991     fprintf (outf, "(nil)\n");
5992   else
5993     {
5994       int i;
5995       enum bb_state { NOT_IN_BB, IN_ONE_BB, IN_MULTIPLE_BB };
5996       int max_uid = get_max_uid ();
5997       basic_block *start = (basic_block *)
5998         xcalloc (max_uid, sizeof (basic_block));
5999       basic_block *end = (basic_block *)
6000         xcalloc (max_uid, sizeof (basic_block));
6001       enum bb_state *in_bb_p = (enum bb_state *)
6002         xcalloc (max_uid, sizeof (enum bb_state));
6003
6004       for (i = n_basic_blocks - 1; i >= 0; i--)
6005         {
6006           basic_block bb = BASIC_BLOCK (i);
6007           rtx x;
6008
6009           start[INSN_UID (bb->head)] = bb;
6010           end[INSN_UID (bb->end)] = bb;
6011           for (x = bb->head; x != NULL_RTX; x = NEXT_INSN (x))
6012             {
6013               enum bb_state state = IN_MULTIPLE_BB;
6014               if (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
6015                 state = IN_ONE_BB;
6016               in_bb_p[INSN_UID (x)] = state;
6017
6018               if (x == bb->end)
6019                 break;
6020             }
6021         }
6022
6023       for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
6024         {
6025           int did_output;
6026           basic_block bb;
6027
6028           if ((bb = start[INSN_UID (tmp_rtx)]) != NULL)
6029             {
6030               fprintf (outf, ";; Start of basic block %d, registers live:",
6031                        bb->index);
6032               dump_regset (bb->global_live_at_start, outf);
6033               putc ('\n', outf);
6034             }
6035
6036           if (in_bb_p[INSN_UID (tmp_rtx)] == NOT_IN_BB
6037               && GET_CODE (tmp_rtx) != NOTE
6038               && GET_CODE (tmp_rtx) != BARRIER)
6039             fprintf (outf, ";; Insn is not within a basic block\n");
6040           else if (in_bb_p[INSN_UID (tmp_rtx)] == IN_MULTIPLE_BB)
6041             fprintf (outf, ";; Insn is in multiple basic blocks\n");
6042
6043           did_output = print_rtl_single (outf, tmp_rtx);
6044
6045           if ((bb = end[INSN_UID (tmp_rtx)]) != NULL)
6046             {
6047               fprintf (outf, ";; End of basic block %d, registers live:\n",
6048                        bb->index);
6049               dump_regset (bb->global_live_at_end, outf);
6050               putc ('\n', outf);
6051             }
6052
6053           if (did_output)
6054             putc ('\n', outf);
6055         }
6056
6057       free (start);
6058       free (end);
6059       free (in_bb_p);
6060     }
6061
6062   if (current_function_epilogue_delay_list != 0)
6063     {
6064       fprintf (outf, "\n;; Insns in epilogue delay list:\n\n");
6065       for (tmp_rtx = current_function_epilogue_delay_list; tmp_rtx != 0;
6066            tmp_rtx = XEXP (tmp_rtx, 1))
6067         print_rtl_single (outf, XEXP (tmp_rtx, 0));
6068     }
6069 }
6070
6071 /* Compute dominator relationships using new flow graph structures.  */
6072
6073 void
6074 compute_flow_dominators (dominators, post_dominators)
6075      sbitmap *dominators;
6076      sbitmap *post_dominators;
6077 {
6078   int bb;
6079   sbitmap *temp_bitmap;
6080   edge e;
6081   basic_block *worklist, *workend, *qin, *qout;
6082   int qlen;
6083
6084   /* Allocate a worklist array/queue.  Entries are only added to the
6085      list if they were not already on the list.  So the size is
6086      bounded by the number of basic blocks.  */
6087   worklist = (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks);
6088   workend = &worklist[n_basic_blocks];
6089
6090   temp_bitmap = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
6091   sbitmap_vector_zero (temp_bitmap, n_basic_blocks);
6092
6093   if (dominators)
6094     {
6095       /* The optimistic setting of dominators requires us to put every
6096          block on the work list initially.  */
6097       qin = qout = worklist;
6098       for (bb = 0; bb < n_basic_blocks; bb++)
6099         {
6100           *qin++ = BASIC_BLOCK (bb);
6101           BASIC_BLOCK (bb)->aux = BASIC_BLOCK (bb);
6102         }
6103       qlen = n_basic_blocks;
6104       qin = worklist;
6105
6106       /* We want a maximal solution, so initially assume everything dominates
6107          everything else.  */
6108       sbitmap_vector_ones (dominators, n_basic_blocks);
6109
6110       /* Mark successors of the entry block so we can identify them below.  */
6111       for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
6112         e->dest->aux = ENTRY_BLOCK_PTR;
6113
6114       /* Iterate until the worklist is empty.  */
6115       while (qlen)
6116         {
6117           /* Take the first entry off the worklist.  */
6118           basic_block b = *qout++;
6119           if (qout >= workend)
6120             qout = worklist;
6121           qlen--;
6122
6123           bb = b->index;
6124
6125           /* Compute the intersection of the dominators of all the
6126              predecessor blocks.
6127
6128              If one of the predecessor blocks is the ENTRY block, then the
6129              intersection of the dominators of the predecessor blocks is
6130              defined as the null set.  We can identify such blocks by the
6131              special value in the AUX field in the block structure.  */
6132           if (b->aux == ENTRY_BLOCK_PTR)
6133             {
6134               /* Do not clear the aux field for blocks which are
6135                  successors of the ENTRY block.  That way we never add
6136                  them to the worklist again.
6137
6138                  The intersect of dominators of the preds of this block is
6139                  defined as the null set.  */
6140               sbitmap_zero (temp_bitmap[bb]);
6141             }
6142           else
6143             {
6144               /* Clear the aux field of this block so it can be added to
6145                  the worklist again if necessary.  */
6146               b->aux = NULL;
6147               sbitmap_intersection_of_preds (temp_bitmap[bb], dominators, bb);
6148             }
6149
6150           /* Make sure each block always dominates itself.  */
6151           SET_BIT (temp_bitmap[bb], bb);
6152
6153           /* If the out state of this block changed, then we need to
6154              add the successors of this block to the worklist if they
6155              are not already on the worklist.  */
6156           if (sbitmap_a_and_b (dominators[bb], dominators[bb], temp_bitmap[bb]))
6157             {
6158               for (e = b->succ; e; e = e->succ_next)
6159                 {
6160                   if (!e->dest->aux && e->dest != EXIT_BLOCK_PTR)
6161                     {
6162                       *qin++ = e->dest;
6163                       if (qin >= workend)
6164                         qin = worklist;
6165                       qlen++;
6166
6167                       e->dest->aux = e;
6168                     }
6169                 }
6170             }
6171         }
6172     }
6173
6174   if (post_dominators)
6175     {
6176       /* The optimistic setting of dominators requires us to put every
6177          block on the work list initially.  */
6178       qin = qout = worklist;
6179       for (bb = 0; bb < n_basic_blocks; bb++)
6180         {
6181           *qin++ = BASIC_BLOCK (bb);
6182           BASIC_BLOCK (bb)->aux = BASIC_BLOCK (bb);
6183         }
6184       qlen = n_basic_blocks;
6185       qin = worklist;
6186
6187       /* We want a maximal solution, so initially assume everything post
6188          dominates everything else.  */
6189       sbitmap_vector_ones (post_dominators, n_basic_blocks);
6190
6191       /* Mark predecessors of the exit block so we can identify them below.  */
6192       for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
6193         e->src->aux = EXIT_BLOCK_PTR;
6194
6195       /* Iterate until the worklist is empty.  */
6196       while (qlen)
6197         {
6198           /* Take the first entry off the worklist.  */
6199           basic_block b = *qout++;
6200           if (qout >= workend)
6201             qout = worklist;
6202           qlen--;
6203
6204           bb = b->index;
6205
6206           /* Compute the intersection of the post dominators of all the
6207              successor blocks.
6208
6209              If one of the successor blocks is the EXIT block, then the
6210              intersection of the dominators of the successor blocks is
6211              defined as the null set.  We can identify such blocks by the
6212              special value in the AUX field in the block structure.  */
6213           if (b->aux == EXIT_BLOCK_PTR)
6214             {
6215               /* Do not clear the aux field for blocks which are
6216                  predecessors of the EXIT block.  That way we we never
6217                  add them to the worklist again.
6218
6219                  The intersect of dominators of the succs of this block is
6220                  defined as the null set.  */
6221               sbitmap_zero (temp_bitmap[bb]);
6222             }
6223           else
6224             {
6225               /* Clear the aux field of this block so it can be added to
6226                  the worklist again if necessary.  */
6227               b->aux = NULL;
6228               sbitmap_intersection_of_succs (temp_bitmap[bb],
6229                                              post_dominators, bb);
6230             }
6231
6232           /* Make sure each block always post dominates itself.  */
6233           SET_BIT (temp_bitmap[bb], bb);
6234
6235           /* If the out state of this block changed, then we need to
6236              add the successors of this block to the worklist if they
6237              are not already on the worklist.  */
6238           if (sbitmap_a_and_b (post_dominators[bb],
6239                                post_dominators[bb],
6240                                temp_bitmap[bb]))
6241             {
6242               for (e = b->pred; e; e = e->pred_next)
6243                 {
6244                   if (!e->src->aux && e->src != ENTRY_BLOCK_PTR)
6245                     {
6246                       *qin++ = e->src;
6247                       if (qin >= workend)
6248                         qin = worklist;
6249                       qlen++;
6250
6251                       e->src->aux = e;
6252                     }
6253                 }
6254             }
6255         }
6256     }
6257
6258   free (worklist);
6259   free (temp_bitmap);
6260 }
6261
6262 /* Given DOMINATORS, compute the immediate dominators into IDOM.  If a
6263    block dominates only itself, its entry remains as INVALID_BLOCK.  */
6264
6265 void
6266 compute_immediate_dominators (idom, dominators)
6267      int *idom;
6268      sbitmap *dominators;
6269 {
6270   sbitmap *tmp;
6271   int b;
6272
6273   tmp = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
6274
6275   /* Begin with tmp(n) = dom(n) - { n }.  */
6276   for (b = n_basic_blocks; --b >= 0;)
6277     {
6278       sbitmap_copy (tmp[b], dominators[b]);
6279       RESET_BIT (tmp[b], b);
6280     }
6281
6282   /* Subtract out all of our dominator's dominators.  */
6283   for (b = n_basic_blocks; --b >= 0;)
6284     {
6285       sbitmap tmp_b = tmp[b];
6286       int s;
6287
6288       for (s = n_basic_blocks; --s >= 0;)
6289         if (TEST_BIT (tmp_b, s))
6290           sbitmap_difference (tmp_b, tmp_b, tmp[s]);
6291     }
6292
6293   /* Find the one bit set in the bitmap and put it in the output array.  */
6294   for (b = n_basic_blocks; --b >= 0;)
6295     {
6296       int t;
6297       EXECUTE_IF_SET_IN_SBITMAP (tmp[b], 0, t, { idom[b] = t; });
6298     }
6299
6300   sbitmap_vector_free (tmp);
6301 }
6302
6303 /* Given POSTDOMINATORS, compute the immediate postdominators into
6304    IDOM.  If a block is only dominated by itself, its entry remains as
6305    INVALID_BLOCK.  */
6306
6307 void
6308 compute_immediate_postdominators (idom, postdominators)
6309      int *idom;
6310      sbitmap *postdominators;
6311 {
6312   compute_immediate_dominators (idom, postdominators);
6313 }
6314
6315 /* Recompute register set/reference counts immediately prior to register
6316    allocation.
6317
6318    This avoids problems with set/reference counts changing to/from values
6319    which have special meanings to the register allocators.
6320
6321    Additionally, the reference counts are the primary component used by the
6322    register allocators to prioritize pseudos for allocation to hard regs.
6323    More accurate reference counts generally lead to better register allocation.
6324
6325    F is the first insn to be scanned.
6326
6327    LOOP_STEP denotes how much loop_depth should be incremented per
6328    loop nesting level in order to increase the ref count more for
6329    references in a loop.
6330
6331    It might be worthwhile to update REG_LIVE_LENGTH, REG_BASIC_BLOCK and
6332    possibly other information which is used by the register allocators.  */
6333
6334 void
6335 recompute_reg_usage (f, loop_step)
6336      rtx f ATTRIBUTE_UNUSED;
6337      int loop_step ATTRIBUTE_UNUSED;
6338 {
6339   allocate_reg_life_data ();
6340   update_life_info (NULL, UPDATE_LIFE_LOCAL, PROP_REG_INFO);
6341 }
6342
6343 /* Optionally removes all the REG_DEAD and REG_UNUSED notes from a set of
6344    blocks.  If BLOCKS is NULL, assume the universal set.  Returns a count
6345    of the number of registers that died.  */
6346
6347 int
6348 count_or_remove_death_notes (blocks, kill)
6349      sbitmap blocks;
6350      int kill;
6351 {
6352   int i, count = 0;
6353
6354   for (i = n_basic_blocks - 1; i >= 0; --i)
6355     {
6356       basic_block bb;
6357       rtx insn;
6358
6359       if (blocks && ! TEST_BIT (blocks, i))
6360         continue;
6361
6362       bb = BASIC_BLOCK (i);
6363
6364       for (insn = bb->head;; insn = NEXT_INSN (insn))
6365         {
6366           if (INSN_P (insn))
6367             {
6368               rtx *pprev = &REG_NOTES (insn);
6369               rtx link = *pprev;
6370
6371               while (link)
6372                 {
6373                   switch (REG_NOTE_KIND (link))
6374                     {
6375                     case REG_DEAD:
6376                       if (GET_CODE (XEXP (link, 0)) == REG)
6377                         {
6378                           rtx reg = XEXP (link, 0);
6379                           int n;
6380
6381                           if (REGNO (reg) >= FIRST_PSEUDO_REGISTER)
6382                             n = 1;
6383                           else
6384                             n = HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg));
6385                           count += n;
6386                         }
6387                       /* Fall through.  */
6388
6389                     case REG_UNUSED:
6390                       if (kill)
6391                         {
6392                           rtx next = XEXP (link, 1);
6393                           free_EXPR_LIST_node (link);
6394                           *pprev = link = next;
6395                           break;
6396                         }
6397                       /* Fall through.  */
6398
6399                     default:
6400                       pprev = &XEXP (link, 1);
6401                       link = *pprev;
6402                       break;
6403                     }
6404                 }
6405             }
6406
6407           if (insn == bb->end)
6408             break;
6409         }
6410     }
6411
6412   return count;
6413 }
6414
6415 /* Record INSN's block as BB.  */
6416
6417 void
6418 set_block_for_insn (insn, bb)
6419      rtx insn;
6420      basic_block bb;
6421 {
6422   size_t uid = INSN_UID (insn);
6423   if (uid >= basic_block_for_insn->num_elements)
6424     {
6425       int new_size;
6426
6427       /* Add one-eighth the size so we don't keep calling xrealloc.  */
6428       new_size = uid + (uid + 7) / 8;
6429
6430       VARRAY_GROW (basic_block_for_insn, new_size);
6431     }
6432   VARRAY_BB (basic_block_for_insn, uid) = bb;
6433 }
6434
6435 /* Record INSN's block number as BB.  */
6436 /* ??? This has got to go.  */
6437
6438 void
6439 set_block_num (insn, bb)
6440      rtx insn;
6441      int bb;
6442 {
6443   set_block_for_insn (insn, BASIC_BLOCK (bb));
6444 }
6445 \f
6446 /* Verify the CFG consistency.  This function check some CFG invariants and
6447    aborts when something is wrong.  Hope that this function will help to
6448    convert many optimization passes to preserve CFG consistent.
6449
6450    Currently it does following checks:
6451
6452    - test head/end pointers
6453    - overlapping of basic blocks
6454    - edge list corectness
6455    - headers of basic blocks (the NOTE_INSN_BASIC_BLOCK note)
6456    - tails of basic blocks (ensure that boundary is necesary)
6457    - scans body of the basic block for JUMP_INSN, CODE_LABEL
6458      and NOTE_INSN_BASIC_BLOCK
6459    - check that all insns are in the basic blocks
6460    (except the switch handling code, barriers and notes)
6461    - check that all returns are followed by barriers
6462
6463    In future it can be extended check a lot of other stuff as well
6464    (reachability of basic blocks, life information, etc. etc.).  */
6465
6466 void
6467 verify_flow_info ()
6468 {
6469   const int max_uid = get_max_uid ();
6470   const rtx rtx_first = get_insns ();
6471   rtx last_head = get_last_insn ();
6472   basic_block *bb_info;
6473   rtx x;
6474   int i, last_bb_num_seen, num_bb_notes, err = 0;
6475
6476   bb_info = (basic_block *) xcalloc (max_uid, sizeof (basic_block));
6477
6478   for (i = n_basic_blocks - 1; i >= 0; i--)
6479     {
6480       basic_block bb = BASIC_BLOCK (i);
6481       rtx head = bb->head;
6482       rtx end = bb->end;
6483
6484       /* Verify the end of the basic block is in the INSN chain.  */
6485       for (x = last_head; x != NULL_RTX; x = PREV_INSN (x))
6486         if (x == end)
6487           break;
6488       if (!x)
6489         {
6490           error ("End insn %d for block %d not found in the insn stream.",
6491                  INSN_UID (end), bb->index);
6492           err = 1;
6493         }
6494
6495       /* Work backwards from the end to the head of the basic block
6496          to verify the head is in the RTL chain.  */
6497       for (; x != NULL_RTX; x = PREV_INSN (x))
6498         {
6499           /* While walking over the insn chain, verify insns appear
6500              in only one basic block and initialize the BB_INFO array
6501              used by other passes.  */
6502           if (bb_info[INSN_UID (x)] != NULL)
6503             {
6504               error ("Insn %d is in multiple basic blocks (%d and %d)",
6505                      INSN_UID (x), bb->index, bb_info[INSN_UID (x)]->index);
6506               err = 1;
6507             }
6508           bb_info[INSN_UID (x)] = bb;
6509
6510           if (x == head)
6511             break;
6512         }
6513       if (!x)
6514         {
6515           error ("Head insn %d for block %d not found in the insn stream.",
6516                  INSN_UID (head), bb->index);
6517           err = 1;
6518         }
6519
6520       last_head = x;
6521     }
6522
6523   /* Now check the basic blocks (boundaries etc.) */
6524   for (i = n_basic_blocks - 1; i >= 0; i--)
6525     {
6526       basic_block bb = BASIC_BLOCK (i);
6527       /* Check corectness of edge lists */
6528       edge e;
6529
6530       e = bb->succ;
6531       while (e)
6532         {
6533           if (e->src != bb)
6534             {
6535               fprintf (stderr,
6536                        "verify_flow_info: Basic block %d succ edge is corrupted\n",
6537                        bb->index);
6538               fprintf (stderr, "Predecessor: ");
6539               dump_edge_info (stderr, e, 0);
6540               fprintf (stderr, "\nSuccessor: ");
6541               dump_edge_info (stderr, e, 1);
6542               fflush (stderr);
6543               err = 1;
6544             }
6545           if (e->dest != EXIT_BLOCK_PTR)
6546             {
6547               edge e2 = e->dest->pred;
6548               while (e2 && e2 != e)
6549                 e2 = e2->pred_next;
6550               if (!e2)
6551                 {
6552                   error ("Basic block %i edge lists are corrupted", bb->index);
6553                   err = 1;
6554                 }
6555             }
6556           e = e->succ_next;
6557         }
6558
6559       e = bb->pred;
6560       while (e)
6561         {
6562           if (e->dest != bb)
6563             {
6564               error ("Basic block %d pred edge is corrupted", bb->index);
6565               fputs ("Predecessor: ", stderr);
6566               dump_edge_info (stderr, e, 0);
6567               fputs ("\nSuccessor: ", stderr);
6568               dump_edge_info (stderr, e, 1);
6569               fputc ('\n', stderr);
6570               err = 1;
6571             }
6572           if (e->src != ENTRY_BLOCK_PTR)
6573             {
6574               edge e2 = e->src->succ;
6575               while (e2 && e2 != e)
6576                 e2 = e2->succ_next;
6577               if (!e2)
6578                 {
6579                   error ("Basic block %i edge lists are corrupted", bb->index);
6580                   err = 1;
6581                 }
6582             }
6583           e = e->pred_next;
6584         }
6585
6586       /* OK pointers are correct.  Now check the header of basic
6587          block.  It ought to contain optional CODE_LABEL followed
6588          by NOTE_BASIC_BLOCK.  */
6589       x = bb->head;
6590       if (GET_CODE (x) == CODE_LABEL)
6591         {
6592           if (bb->end == x)
6593             {
6594               error ("NOTE_INSN_BASIC_BLOCK is missing for block %d",
6595                      bb->index);
6596               err = 1;
6597             }
6598           x = NEXT_INSN (x);
6599         }
6600       if (!NOTE_INSN_BASIC_BLOCK_P (x) || NOTE_BASIC_BLOCK (x) != bb)
6601         {
6602           error ("NOTE_INSN_BASIC_BLOCK is missing for block %d\n",
6603                  bb->index);
6604           err = 1;
6605         }
6606
6607       if (bb->end == x)
6608         {
6609           /* Do checks for empty blocks here */
6610         }
6611       else
6612         {
6613           x = NEXT_INSN (x);
6614           while (x)
6615             {
6616               if (NOTE_INSN_BASIC_BLOCK_P (x))
6617                 {
6618                   error ("NOTE_INSN_BASIC_BLOCK %d in the middle of basic block %d",
6619                          INSN_UID (x), bb->index);
6620                   err = 1;
6621                 }
6622
6623               if (x == bb->end)
6624                 break;
6625
6626               if (GET_CODE (x) == JUMP_INSN
6627                   || GET_CODE (x) == CODE_LABEL
6628                   || GET_CODE (x) == BARRIER)
6629                 {
6630                   error ("In basic block %d:", bb->index);
6631                   fatal_insn ("Flow control insn inside a basic block", x);
6632                 }
6633
6634               x = NEXT_INSN (x);
6635             }
6636         }
6637     }
6638
6639   last_bb_num_seen = -1;
6640   num_bb_notes = 0;
6641   x = rtx_first;
6642   while (x)
6643     {
6644       if (NOTE_INSN_BASIC_BLOCK_P (x))
6645         {
6646           basic_block bb = NOTE_BASIC_BLOCK (x);
6647           num_bb_notes++;
6648           if (bb->index != last_bb_num_seen + 1)
6649             fatal ("Basic blocks not numbered consecutively");
6650           last_bb_num_seen = bb->index;
6651         }
6652
6653       if (!bb_info[INSN_UID (x)])
6654         {
6655           switch (GET_CODE (x))
6656             {
6657             case BARRIER:
6658             case NOTE:
6659               break;
6660
6661             case CODE_LABEL:
6662               /* An addr_vec is placed outside any block block.  */
6663               if (NEXT_INSN (x)
6664                   && GET_CODE (NEXT_INSN (x)) == JUMP_INSN
6665                   && (GET_CODE (PATTERN (NEXT_INSN (x))) == ADDR_DIFF_VEC
6666                       || GET_CODE (PATTERN (NEXT_INSN (x))) == ADDR_VEC))
6667                 {
6668                   x = NEXT_INSN (x);
6669                 }
6670
6671               /* But in any case, non-deletable labels can appear anywhere.  */
6672               break;
6673
6674             default:
6675               fatal_insn ("Insn outside basic block", x);
6676             }
6677         }
6678
6679       if (INSN_P (x)
6680           && GET_CODE (x) == JUMP_INSN
6681           && returnjump_p (x) && ! condjump_p (x)
6682           && ! (NEXT_INSN (x) && GET_CODE (NEXT_INSN (x)) == BARRIER))
6683             fatal_insn ("Return not followed by barrier", x);
6684
6685       x = NEXT_INSN (x);
6686     }
6687
6688   if (num_bb_notes != n_basic_blocks)
6689     fatal ("number of bb notes in insn chain (%d) != n_basic_blocks (%d)",
6690            num_bb_notes, n_basic_blocks);
6691
6692   if (err)
6693     abort ();
6694
6695   /* Clean up.  */
6696   free (bb_info);
6697 }
6698 \f
6699 /* Functions to access an edge list with a vector representation.
6700    Enough data is kept such that given an index number, the
6701    pred and succ that edge represents can be determined, or
6702    given a pred and a succ, its index number can be returned.
6703    This allows algorithms which consume a lot of memory to
6704    represent the normally full matrix of edge (pred,succ) with a
6705    single indexed vector,  edge (EDGE_INDEX (pred, succ)), with no
6706    wasted space in the client code due to sparse flow graphs.  */
6707
6708 /* This functions initializes the edge list. Basically the entire
6709    flowgraph is processed, and all edges are assigned a number,
6710    and the data structure is filled in.  */
6711
6712 struct edge_list *
6713 create_edge_list ()
6714 {
6715   struct edge_list *elist;
6716   edge e;
6717   int num_edges;
6718   int x;
6719   int block_count;
6720
6721   block_count = n_basic_blocks + 2;   /* Include the entry and exit blocks.  */
6722
6723   num_edges = 0;
6724
6725   /* Determine the number of edges in the flow graph by counting successor
6726      edges on each basic block.  */
6727   for (x = 0; x < n_basic_blocks; x++)
6728     {
6729       basic_block bb = BASIC_BLOCK (x);
6730
6731       for (e = bb->succ; e; e = e->succ_next)
6732         num_edges++;
6733     }
6734   /* Don't forget successors of the entry block.  */
6735   for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
6736     num_edges++;
6737
6738   elist = (struct edge_list *) xmalloc (sizeof (struct edge_list));
6739   elist->num_blocks = block_count;
6740   elist->num_edges = num_edges;
6741   elist->index_to_edge = (edge *) xmalloc (sizeof (edge) * num_edges);
6742
6743   num_edges = 0;
6744
6745   /* Follow successors of the entry block, and register these edges.  */
6746   for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
6747     {
6748       elist->index_to_edge[num_edges] = e;
6749       num_edges++;
6750     }
6751
6752   for (x = 0; x < n_basic_blocks; x++)
6753     {
6754       basic_block bb = BASIC_BLOCK (x);
6755
6756       /* Follow all successors of blocks, and register these edges.  */
6757       for (e = bb->succ; e; e = e->succ_next)
6758         {
6759           elist->index_to_edge[num_edges] = e;
6760           num_edges++;
6761         }
6762     }
6763   return elist;
6764 }
6765
6766 /* This function free's memory associated with an edge list.  */
6767
6768 void
6769 free_edge_list (elist)
6770      struct edge_list *elist;
6771 {
6772   if (elist)
6773     {
6774       free (elist->index_to_edge);
6775       free (elist);
6776     }
6777 }
6778
6779 /* This function provides debug output showing an edge list.  */
6780
6781 void
6782 print_edge_list (f, elist)
6783      FILE *f;
6784      struct edge_list *elist;
6785 {
6786   int x;
6787   fprintf (f, "Compressed edge list, %d BBs + entry & exit, and %d edges\n",
6788            elist->num_blocks - 2, elist->num_edges);
6789
6790   for (x = 0; x < elist->num_edges; x++)
6791     {
6792       fprintf (f, " %-4d - edge(", x);
6793       if (INDEX_EDGE_PRED_BB (elist, x) == ENTRY_BLOCK_PTR)
6794         fprintf (f, "entry,");
6795       else
6796         fprintf (f, "%d,", INDEX_EDGE_PRED_BB (elist, x)->index);
6797
6798       if (INDEX_EDGE_SUCC_BB (elist, x) == EXIT_BLOCK_PTR)
6799         fprintf (f, "exit)\n");
6800       else
6801         fprintf (f, "%d)\n", INDEX_EDGE_SUCC_BB (elist, x)->index);
6802     }
6803 }
6804
6805 /* This function provides an internal consistency check of an edge list,
6806    verifying that all edges are present, and that there are no
6807    extra edges.  */
6808
6809 void
6810 verify_edge_list (f, elist)
6811      FILE *f;
6812      struct edge_list *elist;
6813 {
6814   int x, pred, succ, index;
6815   edge e;
6816
6817   for (x = 0; x < n_basic_blocks; x++)
6818     {
6819       basic_block bb = BASIC_BLOCK (x);
6820
6821       for (e = bb->succ; e; e = e->succ_next)
6822         {
6823           pred = e->src->index;
6824           succ = e->dest->index;
6825           index = EDGE_INDEX (elist, e->src, e->dest);
6826           if (index == EDGE_INDEX_NO_EDGE)
6827             {
6828               fprintf (f, "*p* No index for edge from %d to %d\n", pred, succ);
6829               continue;
6830             }
6831           if (INDEX_EDGE_PRED_BB (elist, index)->index != pred)
6832             fprintf (f, "*p* Pred for index %d should be %d not %d\n",
6833                      index, pred, INDEX_EDGE_PRED_BB (elist, index)->index);
6834           if (INDEX_EDGE_SUCC_BB (elist, index)->index != succ)
6835             fprintf (f, "*p* Succ for index %d should be %d not %d\n",
6836                      index, succ, INDEX_EDGE_SUCC_BB (elist, index)->index);
6837         }
6838     }
6839   for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
6840     {
6841       pred = e->src->index;
6842       succ = e->dest->index;
6843       index = EDGE_INDEX (elist, e->src, e->dest);
6844       if (index == EDGE_INDEX_NO_EDGE)
6845         {
6846           fprintf (f, "*p* No index for edge from %d to %d\n", pred, succ);
6847           continue;
6848         }
6849       if (INDEX_EDGE_PRED_BB (elist, index)->index != pred)
6850         fprintf (f, "*p* Pred for index %d should be %d not %d\n",
6851                  index, pred, INDEX_EDGE_PRED_BB (elist, index)->index);
6852       if (INDEX_EDGE_SUCC_BB (elist, index)->index != succ)
6853         fprintf (f, "*p* Succ for index %d should be %d not %d\n",
6854                  index, succ, INDEX_EDGE_SUCC_BB (elist, index)->index);
6855     }
6856   /* We've verified that all the edges are in the list, no lets make sure
6857      there are no spurious edges in the list.  */
6858
6859   for (pred = 0; pred < n_basic_blocks; pred++)
6860     for (succ = 0; succ < n_basic_blocks; succ++)
6861       {
6862         basic_block p = BASIC_BLOCK (pred);
6863         basic_block s = BASIC_BLOCK (succ);
6864
6865         int found_edge = 0;
6866
6867         for (e = p->succ; e; e = e->succ_next)
6868           if (e->dest == s)
6869             {
6870               found_edge = 1;
6871               break;
6872             }
6873         for (e = s->pred; e; e = e->pred_next)
6874           if (e->src == p)
6875             {
6876               found_edge = 1;
6877               break;
6878             }
6879         if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
6880             == EDGE_INDEX_NO_EDGE && found_edge != 0)
6881           fprintf (f, "*** Edge (%d, %d) appears to not have an index\n",
6882                    pred, succ);
6883         if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
6884             != EDGE_INDEX_NO_EDGE && found_edge == 0)
6885           fprintf (f, "*** Edge (%d, %d) has index %d, but there is no edge\n",
6886                    pred, succ, EDGE_INDEX (elist, BASIC_BLOCK (pred),
6887                                            BASIC_BLOCK (succ)));
6888       }
6889   for (succ = 0; succ < n_basic_blocks; succ++)
6890     {
6891       basic_block p = ENTRY_BLOCK_PTR;
6892       basic_block s = BASIC_BLOCK (succ);
6893
6894       int found_edge = 0;
6895
6896       for (e = p->succ; e; e = e->succ_next)
6897         if (e->dest == s)
6898           {
6899             found_edge = 1;
6900             break;
6901           }
6902       for (e = s->pred; e; e = e->pred_next)
6903         if (e->src == p)
6904           {
6905             found_edge = 1;
6906             break;
6907           }
6908       if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
6909           == EDGE_INDEX_NO_EDGE && found_edge != 0)
6910         fprintf (f, "*** Edge (entry, %d) appears to not have an index\n",
6911                  succ);
6912       if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
6913           != EDGE_INDEX_NO_EDGE && found_edge == 0)
6914         fprintf (f, "*** Edge (entry, %d) has index %d, but no edge exists\n",
6915                  succ, EDGE_INDEX (elist, ENTRY_BLOCK_PTR,
6916                                    BASIC_BLOCK (succ)));
6917     }
6918   for (pred = 0; pred < n_basic_blocks; pred++)
6919     {
6920       basic_block p = BASIC_BLOCK (pred);
6921       basic_block s = EXIT_BLOCK_PTR;
6922
6923       int found_edge = 0;
6924
6925       for (e = p->succ; e; e = e->succ_next)
6926         if (e->dest == s)
6927           {
6928             found_edge = 1;
6929             break;
6930           }
6931       for (e = s->pred; e; e = e->pred_next)
6932         if (e->src == p)
6933           {
6934             found_edge = 1;
6935             break;
6936           }
6937       if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
6938           == EDGE_INDEX_NO_EDGE && found_edge != 0)
6939         fprintf (f, "*** Edge (%d, exit) appears to not have an index\n",
6940                  pred);
6941       if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
6942           != EDGE_INDEX_NO_EDGE && found_edge == 0)
6943         fprintf (f, "*** Edge (%d, exit) has index %d, but no edge exists\n",
6944                  pred, EDGE_INDEX (elist, BASIC_BLOCK (pred),
6945                                    EXIT_BLOCK_PTR));
6946     }
6947 }
6948
6949 /* This routine will determine what, if any, edge there is between
6950    a specified predecessor and successor.  */
6951
6952 int
6953 find_edge_index (edge_list, pred, succ)
6954      struct edge_list *edge_list;
6955      basic_block pred, succ;
6956 {
6957   int x;
6958   for (x = 0; x < NUM_EDGES (edge_list); x++)
6959     {
6960       if (INDEX_EDGE_PRED_BB (edge_list, x) == pred
6961           && INDEX_EDGE_SUCC_BB (edge_list, x) == succ)
6962         return x;
6963     }
6964   return (EDGE_INDEX_NO_EDGE);
6965 }
6966
6967 /* This function will remove an edge from the flow graph.  */
6968
6969 void
6970 remove_edge (e)
6971      edge e;
6972 {
6973   edge last_pred = NULL;
6974   edge last_succ = NULL;
6975   edge tmp;
6976   basic_block src, dest;
6977   src = e->src;
6978   dest = e->dest;
6979   for (tmp = src->succ; tmp && tmp != e; tmp = tmp->succ_next)
6980     last_succ = tmp;
6981
6982   if (!tmp)
6983     abort ();
6984   if (last_succ)
6985     last_succ->succ_next = e->succ_next;
6986   else
6987     src->succ = e->succ_next;
6988
6989   for (tmp = dest->pred; tmp && tmp != e; tmp = tmp->pred_next)
6990     last_pred = tmp;
6991
6992   if (!tmp)
6993     abort ();
6994   if (last_pred)
6995     last_pred->pred_next = e->pred_next;
6996   else
6997     dest->pred = e->pred_next;
6998
6999   n_edges--;
7000   free (e);
7001 }
7002
7003 /* This routine will remove any fake successor edges for a basic block.
7004    When the edge is removed, it is also removed from whatever predecessor
7005    list it is in.  */
7006
7007 static void
7008 remove_fake_successors (bb)
7009      basic_block bb;
7010 {
7011   edge e;
7012   for (e = bb->succ; e;)
7013     {
7014       edge tmp = e;
7015       e = e->succ_next;
7016       if ((tmp->flags & EDGE_FAKE) == EDGE_FAKE)
7017         remove_edge (tmp);
7018     }
7019 }
7020
7021 /* This routine will remove all fake edges from the flow graph.  If
7022    we remove all fake successors, it will automatically remove all
7023    fake predecessors.  */
7024
7025 void
7026 remove_fake_edges ()
7027 {
7028   int x;
7029
7030   for (x = 0; x < n_basic_blocks; x++)
7031     remove_fake_successors (BASIC_BLOCK (x));
7032
7033   /* We've handled all successors except the entry block's.  */
7034   remove_fake_successors (ENTRY_BLOCK_PTR);
7035 }
7036
7037 /* This function will add a fake edge between any block which has no
7038    successors, and the exit block. Some data flow equations require these
7039    edges to exist.  */
7040
7041 void
7042 add_noreturn_fake_exit_edges ()
7043 {
7044   int x;
7045
7046   for (x = 0; x < n_basic_blocks; x++)
7047     if (BASIC_BLOCK (x)->succ == NULL)
7048       make_edge (NULL, BASIC_BLOCK (x), EXIT_BLOCK_PTR, EDGE_FAKE);
7049 }
7050
7051 /* This function adds a fake edge between any infinite loops to the
7052    exit block.  Some optimizations require a path from each node to
7053    the exit node.
7054
7055    See also Morgan, Figure 3.10, pp. 82-83.
7056
7057    The current implementation is ugly, not attempting to minimize the
7058    number of inserted fake edges.  To reduce the number of fake edges
7059    to insert, add fake edges from _innermost_ loops containing only
7060    nodes not reachable from the exit block.  */
7061
7062 void
7063 connect_infinite_loops_to_exit ()
7064 {
7065   basic_block unvisited_block;
7066
7067   /* Perform depth-first search in the reverse graph to find nodes
7068      reachable from the exit block.  */
7069   struct depth_first_search_dsS dfs_ds;
7070
7071   flow_dfs_compute_reverse_init (&dfs_ds);
7072   flow_dfs_compute_reverse_add_bb (&dfs_ds, EXIT_BLOCK_PTR);
7073
7074   /* Repeatedly add fake edges, updating the unreachable nodes.  */
7075   while (1)
7076     {
7077       unvisited_block = flow_dfs_compute_reverse_execute (&dfs_ds);
7078       if (!unvisited_block)
7079         break;
7080       make_edge (NULL, unvisited_block, EXIT_BLOCK_PTR, EDGE_FAKE);
7081       flow_dfs_compute_reverse_add_bb (&dfs_ds, unvisited_block);
7082     }
7083
7084   flow_dfs_compute_reverse_finish (&dfs_ds);
7085
7086   return;
7087 }
7088
7089 /* Redirect an edge's successor from one block to another.  */
7090
7091 void
7092 redirect_edge_succ (e, new_succ)
7093      edge e;
7094      basic_block new_succ;
7095 {
7096   edge *pe;
7097
7098   /* Disconnect the edge from the old successor block.  */
7099   for (pe = &e->dest->pred; *pe != e; pe = &(*pe)->pred_next)
7100     continue;
7101   *pe = (*pe)->pred_next;
7102
7103   /* Reconnect the edge to the new successor block.  */
7104   e->pred_next = new_succ->pred;
7105   new_succ->pred = e;
7106   e->dest = new_succ;
7107 }
7108
7109 /* Redirect an edge's predecessor from one block to another.  */
7110
7111 void
7112 redirect_edge_pred (e, new_pred)
7113      edge e;
7114      basic_block new_pred;
7115 {
7116   edge *pe;
7117
7118   /* Disconnect the edge from the old predecessor block.  */
7119   for (pe = &e->src->succ; *pe != e; pe = &(*pe)->succ_next)
7120     continue;
7121   *pe = (*pe)->succ_next;
7122
7123   /* Reconnect the edge to the new predecessor block.  */
7124   e->succ_next = new_pred->succ;
7125   new_pred->succ = e;
7126   e->src = new_pred;
7127 }
7128 \f
7129 /* Dump the list of basic blocks in the bitmap NODES.  */
7130
7131 static void
7132 flow_nodes_print (str, nodes, file)
7133      const char *str;
7134      const sbitmap nodes;
7135      FILE *file;
7136 {
7137   int node;
7138
7139   if (! nodes)
7140     return;
7141
7142   fprintf (file, "%s { ", str);
7143   EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {fprintf (file, "%d ", node);});
7144   fputs ("}\n", file);
7145 }
7146
7147
7148 /* Dump the list of edges in the array EDGE_LIST.  */
7149
7150 static void
7151 flow_edge_list_print (str, edge_list, num_edges, file)
7152      const char *str;
7153      const edge *edge_list;
7154      int num_edges;
7155      FILE *file;
7156 {
7157   int i;
7158
7159   if (! edge_list)
7160     return;
7161
7162   fprintf (file, "%s { ", str);
7163   for (i = 0; i < num_edges; i++)
7164     fprintf (file, "%d->%d ", edge_list[i]->src->index,
7165              edge_list[i]->dest->index);
7166   fputs ("}\n", file);
7167 }
7168
7169
7170 /* Dump loop related CFG information.  */
7171
7172 static void
7173 flow_loops_cfg_dump (loops, file)
7174      const struct loops *loops;
7175      FILE *file;
7176 {
7177   int i;
7178
7179   if (! loops->num || ! file || ! loops->cfg.dom)
7180     return;
7181
7182   for (i = 0; i < n_basic_blocks; i++)
7183     {
7184       edge succ;
7185
7186       fprintf (file, ";; %d succs { ", i);
7187       for (succ = BASIC_BLOCK (i)->succ; succ; succ = succ->succ_next)
7188         fprintf (file, "%d ", succ->dest->index);
7189       flow_nodes_print ("} dom", loops->cfg.dom[i], file);
7190     }
7191
7192   /* Dump the DFS node order.  */
7193   if (loops->cfg.dfs_order)
7194     {
7195       fputs (";; DFS order: ", file);
7196       for (i = 0; i < n_basic_blocks; i++)
7197         fprintf (file, "%d ", loops->cfg.dfs_order[i]);
7198       fputs ("\n", file);
7199     }
7200   /* Dump the reverse completion node order.  */
7201   if (loops->cfg.rc_order)
7202     {
7203       fputs (";; RC order: ", file);
7204       for (i = 0; i < n_basic_blocks; i++)
7205         fprintf (file, "%d ", loops->cfg.rc_order[i]);
7206       fputs ("\n", file);
7207     }
7208 }
7209
7210 /* Return non-zero if the nodes of LOOP are a subset of OUTER.  */
7211
7212 static int
7213 flow_loop_nested_p (outer, loop)
7214      struct loop *outer;
7215      struct loop *loop;
7216 {
7217   return sbitmap_a_subset_b_p (loop->nodes, outer->nodes);
7218 }
7219
7220
7221 /* Dump the loop information specified by LOOP to the stream FILE
7222    using auxiliary dump callback function LOOP_DUMP_AUX if non null.  */
7223 void
7224 flow_loop_dump (loop, file, loop_dump_aux, verbose)
7225      const struct loop *loop;
7226      FILE *file;
7227      void (*loop_dump_aux)(const struct loop *, FILE *, int);
7228      int verbose;
7229 {
7230   if (! loop || ! loop->header)
7231     return;
7232
7233   fprintf (file, ";;\n;; Loop %d (%d to %d):%s%s\n",
7234            loop->num, INSN_UID (loop->first->head),
7235            INSN_UID (loop->last->end),
7236            loop->shared ? " shared" : "",
7237            loop->invalid ? " invalid" : "");
7238   fprintf (file, ";;  header %d, latch %d, pre-header %d, first %d, last %d\n",
7239            loop->header->index, loop->latch->index,
7240            loop->pre_header ? loop->pre_header->index : -1,
7241            loop->first->index, loop->last->index);
7242   fprintf (file, ";;  depth %d, level %d, outer %ld\n",
7243            loop->depth, loop->level,
7244            (long) (loop->outer ? loop->outer->num : -1));
7245
7246   flow_edge_list_print (";;   entry edges", loop->entry_edges,
7247                         loop->num_entries, file);
7248   fprintf (file, ";;  %d", loop->num_nodes);
7249   flow_nodes_print (" nodes", loop->nodes, file);
7250   flow_edge_list_print (";;   exit edges", loop->exit_edges,
7251                         loop->num_exits, file);
7252
7253   if (loop_dump_aux)
7254     loop_dump_aux (loop, file, verbose);
7255 }
7256
7257
7258 /* Dump the loop information specified by LOOPS to the stream FILE,
7259    using auxiliary dump callback function LOOP_DUMP_AUX if non null.  */
7260 void
7261 flow_loops_dump (loops, file, loop_dump_aux, verbose)
7262      const struct loops *loops;
7263      FILE *file;
7264      void (*loop_dump_aux)(const struct loop *, FILE *, int);
7265      int verbose;
7266 {
7267   int i;
7268   int num_loops;
7269
7270   num_loops = loops->num;
7271   if (! num_loops || ! file)
7272     return;
7273
7274   fprintf (file, ";; %d loops found, %d levels\n",
7275            num_loops, loops->levels);
7276
7277   for (i = 0; i < num_loops; i++)
7278     {
7279       struct loop *loop = &loops->array[i];
7280
7281       flow_loop_dump (loop, file, loop_dump_aux, verbose);
7282
7283       if (loop->shared)
7284         {
7285           int j;
7286
7287           for (j = 0; j < i; j++)
7288             {
7289               struct loop *oloop = &loops->array[j];
7290
7291               if (loop->header == oloop->header)
7292                 {
7293                   int disjoint;
7294                   int smaller;
7295
7296                   smaller = loop->num_nodes < oloop->num_nodes;
7297
7298                   /* If the union of LOOP and OLOOP is different than
7299                      the larger of LOOP and OLOOP then LOOP and OLOOP
7300                      must be disjoint.  */
7301                   disjoint = ! flow_loop_nested_p (smaller ? loop : oloop,
7302                                                    smaller ? oloop : loop);
7303                   fprintf (file,
7304                            ";; loop header %d shared by loops %d, %d %s\n",
7305                            loop->header->index, i, j,
7306                            disjoint ? "disjoint" : "nested");
7307                 }
7308             }
7309         }
7310     }
7311
7312   if (verbose)
7313     flow_loops_cfg_dump (loops, file);
7314 }
7315
7316
7317 /* Free all the memory allocated for LOOPS.  */
7318
7319 void
7320 flow_loops_free (loops)
7321      struct loops *loops;
7322 {
7323   if (loops->array)
7324     {
7325       int i;
7326
7327       if (! loops->num)
7328         abort ();
7329
7330       /* Free the loop descriptors.  */
7331       for (i = 0; i < loops->num; i++)
7332         {
7333           struct loop *loop = &loops->array[i];
7334
7335           if (loop->nodes)
7336             sbitmap_free (loop->nodes);
7337           if (loop->entry_edges)
7338             free (loop->entry_edges);
7339           if (loop->exit_edges)
7340             free (loop->exit_edges);
7341         }
7342       free (loops->array);
7343       loops->array = NULL;
7344
7345       if (loops->cfg.dom)
7346         sbitmap_vector_free (loops->cfg.dom);
7347       if (loops->cfg.dfs_order)
7348         free (loops->cfg.dfs_order);
7349
7350       sbitmap_free (loops->shared_headers);
7351     }
7352 }
7353
7354
7355 /* Find the entry edges into the loop with header HEADER and nodes
7356    NODES and store in ENTRY_EDGES array.  Return the number of entry
7357    edges from the loop.  */
7358
7359 static int
7360 flow_loop_entry_edges_find (header, nodes, entry_edges)
7361      basic_block header;
7362      const sbitmap nodes;
7363      edge **entry_edges;
7364 {
7365   edge e;
7366   int num_entries;
7367
7368   *entry_edges = NULL;
7369
7370   num_entries = 0;
7371   for (e = header->pred; e; e = e->pred_next)
7372     {
7373       basic_block src = e->src;
7374
7375       if (src == ENTRY_BLOCK_PTR || ! TEST_BIT (nodes, src->index))
7376         num_entries++;
7377     }
7378
7379   if (! num_entries)
7380     abort ();
7381
7382   *entry_edges = (edge *) xmalloc (num_entries * sizeof (edge *));
7383
7384   num_entries = 0;
7385   for (e = header->pred; e; e = e->pred_next)
7386     {
7387       basic_block src = e->src;
7388
7389       if (src == ENTRY_BLOCK_PTR || ! TEST_BIT (nodes, src->index))
7390         (*entry_edges)[num_entries++] = e;
7391     }
7392
7393   return num_entries;
7394 }
7395
7396
7397 /* Find the exit edges from the loop using the bitmap of loop nodes
7398    NODES and store in EXIT_EDGES array.  Return the number of
7399    exit edges from the loop.  */
7400
7401 static int
7402 flow_loop_exit_edges_find (nodes, exit_edges)
7403      const sbitmap nodes;
7404      edge **exit_edges;
7405 {
7406   edge e;
7407   int node;
7408   int num_exits;
7409
7410   *exit_edges = NULL;
7411
7412   /* Check all nodes within the loop to see if there are any
7413      successors not in the loop.  Note that a node may have multiple
7414      exiting edges ?????  A node can have one jumping edge and one fallthru
7415      edge so only one of these can exit the loop.  */
7416   num_exits = 0;
7417   EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {
7418     for (e = BASIC_BLOCK (node)->succ; e; e = e->succ_next)
7419       {
7420         basic_block dest = e->dest;
7421
7422         if (dest == EXIT_BLOCK_PTR || ! TEST_BIT (nodes, dest->index))
7423             num_exits++;
7424       }
7425   });
7426
7427   if (! num_exits)
7428     return 0;
7429
7430   *exit_edges = (edge *) xmalloc (num_exits * sizeof (edge *));
7431
7432   /* Store all exiting edges into an array.  */
7433   num_exits = 0;
7434   EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {
7435     for (e = BASIC_BLOCK (node)->succ; e; e = e->succ_next)
7436       {
7437         basic_block dest = e->dest;
7438
7439         if (dest == EXIT_BLOCK_PTR || ! TEST_BIT (nodes, dest->index))
7440           (*exit_edges)[num_exits++] = e;
7441       }
7442   });
7443
7444   return num_exits;
7445 }
7446
7447
7448 /* Find the nodes contained within the loop with header HEADER and
7449    latch LATCH and store in NODES.  Return the number of nodes within
7450    the loop.  */
7451
7452 static int
7453 flow_loop_nodes_find (header, latch, nodes)
7454      basic_block header;
7455      basic_block latch;
7456      sbitmap nodes;
7457 {
7458   basic_block *stack;
7459   int sp;
7460   int num_nodes = 0;
7461
7462   stack = (basic_block *) xmalloc (n_basic_blocks * sizeof (basic_block));
7463   sp = 0;
7464
7465   /* Start with only the loop header in the set of loop nodes.  */
7466   sbitmap_zero (nodes);
7467   SET_BIT (nodes, header->index);
7468   num_nodes++;
7469   header->loop_depth++;
7470
7471   /* Push the loop latch on to the stack.  */
7472   if (! TEST_BIT (nodes, latch->index))
7473     {
7474       SET_BIT (nodes, latch->index);
7475       latch->loop_depth++;
7476       num_nodes++;
7477       stack[sp++] = latch;
7478     }
7479
7480   while (sp)
7481     {
7482       basic_block node;
7483       edge e;
7484
7485       node = stack[--sp];
7486       for (e = node->pred; e; e = e->pred_next)
7487         {
7488           basic_block ancestor = e->src;
7489
7490           /* If each ancestor not marked as part of loop, add to set of
7491              loop nodes and push on to stack.  */
7492           if (ancestor != ENTRY_BLOCK_PTR
7493               && ! TEST_BIT (nodes, ancestor->index))
7494             {
7495               SET_BIT (nodes, ancestor->index);
7496               ancestor->loop_depth++;
7497               num_nodes++;
7498               stack[sp++] = ancestor;
7499             }
7500         }
7501     }
7502   free (stack);
7503   return num_nodes;
7504 }
7505
7506 /* Compute the depth first search order and store in the array
7507   DFS_ORDER if non-zero, marking the nodes visited in VISITED.  If
7508   RC_ORDER is non-zero, return the reverse completion number for each
7509   node.  Returns the number of nodes visited.  A depth first search
7510   tries to get as far away from the starting point as quickly as
7511   possible.  */
7512
7513 static int
7514 flow_depth_first_order_compute (dfs_order, rc_order)
7515      int *dfs_order;
7516      int *rc_order;
7517 {
7518   edge *stack;
7519   int sp;
7520   int dfsnum = 0;
7521   int rcnum = n_basic_blocks - 1;
7522   sbitmap visited;
7523
7524   /* Allocate stack for back-tracking up CFG.  */
7525   stack = (edge *) xmalloc ((n_basic_blocks + 1) * sizeof (edge));
7526   sp = 0;
7527
7528   /* Allocate bitmap to track nodes that have been visited.  */
7529   visited = sbitmap_alloc (n_basic_blocks);
7530
7531   /* None of the nodes in the CFG have been visited yet.  */
7532   sbitmap_zero (visited);
7533
7534   /* Push the first edge on to the stack.  */
7535   stack[sp++] = ENTRY_BLOCK_PTR->succ;
7536
7537   while (sp)
7538     {
7539       edge e;
7540       basic_block src;
7541       basic_block dest;
7542
7543       /* Look at the edge on the top of the stack.  */
7544       e = stack[sp - 1];
7545       src = e->src;
7546       dest = e->dest;
7547
7548       /* Check if the edge destination has been visited yet.  */
7549       if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index))
7550         {
7551           /* Mark that we have visited the destination.  */
7552           SET_BIT (visited, dest->index);
7553
7554           if (dfs_order)
7555             dfs_order[dfsnum++] = dest->index;
7556
7557           if (dest->succ)
7558             {
7559               /* Since the DEST node has been visited for the first
7560                  time, check its successors.  */
7561               stack[sp++] = dest->succ;
7562             }
7563           else
7564             {
7565               /* There are no successors for the DEST node so assign
7566                  its reverse completion number.  */
7567               if (rc_order)
7568                 rc_order[rcnum--] = dest->index;
7569             }
7570         }
7571       else
7572         {
7573           if (! e->succ_next && src != ENTRY_BLOCK_PTR)
7574             {
7575               /* There are no more successors for the SRC node
7576                  so assign its reverse completion number.  */
7577               if (rc_order)
7578                 rc_order[rcnum--] = src->index;
7579             }
7580
7581           if (e->succ_next)
7582             stack[sp - 1] = e->succ_next;
7583           else
7584             sp--;
7585         }
7586     }
7587
7588   free (stack);
7589   sbitmap_free (visited);
7590
7591   /* The number of nodes visited should not be greater than
7592      n_basic_blocks.  */
7593   if (dfsnum > n_basic_blocks)
7594     abort ();
7595
7596   /* There are some nodes left in the CFG that are unreachable.  */
7597   if (dfsnum < n_basic_blocks)
7598     abort ();
7599   return dfsnum;
7600 }
7601
7602 /* Compute the depth first search order on the _reverse_ graph and
7603    store in the array DFS_ORDER, marking the nodes visited in VISITED.
7604    Returns the number of nodes visited.
7605
7606    The computation is split into three pieces:
7607
7608    flow_dfs_compute_reverse_init () creates the necessary data
7609    structures.
7610
7611    flow_dfs_compute_reverse_add_bb () adds a basic block to the data
7612    structures.  The block will start the search.
7613
7614    flow_dfs_compute_reverse_execute () continues (or starts) the
7615    search using the block on the top of the stack, stopping when the
7616    stack is empty.
7617
7618    flow_dfs_compute_reverse_finish () destroys the necessary data
7619    structures.
7620
7621    Thus, the user will probably call ..._init(), call ..._add_bb() to
7622    add a beginning basic block to the stack, call ..._execute(),
7623    possibly add another bb to the stack and again call ..._execute(),
7624    ..., and finally call _finish().  */
7625
7626 /* Initialize the data structures used for depth-first search on the
7627    reverse graph.  If INITIALIZE_STACK is nonzero, the exit block is
7628    added to the basic block stack.  DATA is the current depth-first
7629    search context.  If INITIALIZE_STACK is non-zero, there is an
7630    element on the stack.  */
7631
7632 static void
7633 flow_dfs_compute_reverse_init (data)
7634      depth_first_search_ds data;
7635 {
7636   /* Allocate stack for back-tracking up CFG.  */
7637   data->stack =
7638     (basic_block *) xmalloc ((n_basic_blocks - (INVALID_BLOCK + 1))
7639                              * sizeof (basic_block));
7640   data->sp = 0;
7641
7642   /* Allocate bitmap to track nodes that have been visited.  */
7643   data->visited_blocks = sbitmap_alloc (n_basic_blocks - (INVALID_BLOCK + 1));
7644
7645   /* None of the nodes in the CFG have been visited yet.  */
7646   sbitmap_zero (data->visited_blocks);
7647
7648   return;
7649 }
7650
7651 /* Add the specified basic block to the top of the dfs data
7652    structures.  When the search continues, it will start at the
7653    block.  */
7654
7655 static void
7656 flow_dfs_compute_reverse_add_bb (data, bb)
7657      depth_first_search_ds data;
7658      basic_block bb;
7659 {
7660   data->stack[data->sp++] = bb;
7661   return;
7662 }
7663
7664 /* Continue the depth-first search through the reverse graph starting
7665    with the block at the stack's top and ending when the stack is
7666    empty.  Visited nodes are marked.  Returns an unvisited basic
7667    block, or NULL if there is none available.  */
7668
7669 static basic_block
7670 flow_dfs_compute_reverse_execute (data)
7671      depth_first_search_ds data;
7672 {
7673   basic_block bb;
7674   edge e;
7675   int i;
7676
7677   while (data->sp > 0)
7678     {
7679       bb = data->stack[--data->sp];
7680
7681       /* Mark that we have visited this node.  */
7682       if (!TEST_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK + 1)))
7683         {
7684           SET_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK + 1));
7685
7686           /* Perform depth-first search on adjacent vertices.  */
7687           for (e = bb->pred; e; e = e->pred_next)
7688             flow_dfs_compute_reverse_add_bb (data, e->src);
7689         }
7690     }
7691
7692   /* Determine if there are unvisited basic blocks.  */
7693   for (i = n_basic_blocks - (INVALID_BLOCK + 1); --i >= 0;)
7694     if (!TEST_BIT (data->visited_blocks, i))
7695       return BASIC_BLOCK (i + (INVALID_BLOCK + 1));
7696   return NULL;
7697 }
7698
7699 /* Destroy the data structures needed for depth-first search on the
7700    reverse graph.  */
7701
7702 static void
7703 flow_dfs_compute_reverse_finish (data)
7704      depth_first_search_ds data;
7705 {
7706   free (data->stack);
7707   sbitmap_free (data->visited_blocks);
7708   return;
7709 }
7710
7711 /* Return the block for the pre-header of the loop with header
7712    HEADER where DOM specifies the dominator information.  Return NULL if
7713    there is no pre-header.  */
7714
7715 static basic_block
7716 flow_loop_pre_header_find (header, dom)
7717      basic_block header;
7718      const sbitmap *dom;
7719 {
7720   basic_block pre_header;
7721   edge e;
7722
7723   /* If block p is a predecessor of the header and is the only block
7724      that the header does not dominate, then it is the pre-header.  */
7725   pre_header = NULL;
7726   for (e = header->pred; e; e = e->pred_next)
7727     {
7728       basic_block node = e->src;
7729
7730       if (node != ENTRY_BLOCK_PTR
7731           && ! TEST_BIT (dom[node->index], header->index))
7732         {
7733           if (pre_header == NULL)
7734             pre_header = node;
7735           else
7736             {
7737               /* There are multiple edges into the header from outside
7738                  the loop so there is no pre-header block.  */
7739               pre_header = NULL;
7740               break;
7741             }
7742         }
7743     }
7744   return pre_header;
7745 }
7746
7747 /* Add LOOP to the loop hierarchy tree where PREVLOOP was the loop
7748    previously added.  The insertion algorithm assumes that the loops
7749    are added in the order found by a depth first search of the CFG.  */
7750
7751 static void
7752 flow_loop_tree_node_add (prevloop, loop)
7753      struct loop *prevloop;
7754      struct loop *loop;
7755 {
7756
7757   if (flow_loop_nested_p (prevloop, loop))
7758     {
7759       prevloop->inner = loop;
7760       loop->outer = prevloop;
7761       return;
7762     }
7763
7764   while (prevloop->outer)
7765     {
7766       if (flow_loop_nested_p (prevloop->outer, loop))
7767         {
7768           prevloop->next = loop;
7769           loop->outer = prevloop->outer;
7770           return;
7771         }
7772       prevloop = prevloop->outer;
7773     }
7774
7775   prevloop->next = loop;
7776   loop->outer = NULL;
7777 }
7778
7779 /* Build the loop hierarchy tree for LOOPS.  */
7780
7781 static void
7782 flow_loops_tree_build (loops)
7783      struct loops *loops;
7784 {
7785   int i;
7786   int num_loops;
7787
7788   num_loops = loops->num;
7789   if (! num_loops)
7790     return;
7791
7792   /* Root the loop hierarchy tree with the first loop found.
7793      Since we used a depth first search this should be the
7794      outermost loop.  */
7795   loops->tree = &loops->array[0];
7796   loops->tree->outer = loops->tree->inner = loops->tree->next = NULL;
7797
7798   /* Add the remaining loops to the tree.  */
7799   for (i = 1; i < num_loops; i++)
7800     flow_loop_tree_node_add (&loops->array[i - 1], &loops->array[i]);
7801 }
7802
7803 /* Helper function to compute loop nesting depth and enclosed loop level
7804    for the natural loop specified by LOOP at the loop depth DEPTH.
7805    Returns the loop level.  */
7806
7807 static int
7808 flow_loop_level_compute (loop, depth)
7809      struct loop *loop;
7810      int depth;
7811 {
7812   struct loop *inner;
7813   int level = 1;
7814
7815   if (! loop)
7816     return 0;
7817
7818   /* Traverse loop tree assigning depth and computing level as the
7819      maximum level of all the inner loops of this loop.  The loop
7820      level is equivalent to the height of the loop in the loop tree
7821      and corresponds to the number of enclosed loop levels (including
7822      itself).  */
7823   for (inner = loop->inner; inner; inner = inner->next)
7824     {
7825       int ilevel;
7826
7827       ilevel = flow_loop_level_compute (inner, depth + 1) + 1;
7828
7829       if (ilevel > level)
7830         level = ilevel;
7831     }
7832   loop->level = level;
7833   loop->depth = depth;
7834   return level;
7835 }
7836
7837 /* Compute the loop nesting depth and enclosed loop level for the loop
7838    hierarchy tree specfied by LOOPS.  Return the maximum enclosed loop
7839    level.  */
7840
7841 static int
7842 flow_loops_level_compute (loops)
7843      struct loops *loops;
7844 {
7845   struct loop *loop;
7846   int level;
7847   int levels = 0;
7848
7849   /* Traverse all the outer level loops.  */
7850   for (loop = loops->tree; loop; loop = loop->next)
7851     {
7852       level = flow_loop_level_compute (loop, 1);
7853       if (level > levels)
7854         levels = level;
7855     }
7856   return levels;
7857 }
7858
7859 /* Find all the natural loops in the function and save in LOOPS structure
7860    and recalculate loop_depth information in basic block structures.
7861    Return the number of natural loops found.  */
7862
7863 int
7864 flow_loops_find (loops)
7865      struct loops *loops;
7866 {
7867   int i;
7868   int b;
7869   int num_loops;
7870   edge e;
7871   sbitmap headers;
7872   sbitmap *dom;
7873   int *dfs_order;
7874   int *rc_order;
7875
7876   loops->num = 0;
7877   loops->array = NULL;
7878   loops->tree = NULL;
7879   dfs_order = NULL;
7880   rc_order = NULL;
7881
7882   /* Taking care of this degenerate case makes the rest of
7883      this code simpler.  */
7884   if (n_basic_blocks == 0)
7885     return 0;
7886
7887   /* Compute the dominators.  */
7888   dom = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
7889   compute_flow_dominators (dom, NULL);
7890
7891   /* Count the number of loop edges (back edges).  This should be the
7892      same as the number of natural loops.  Also clear the loop_depth
7893      and as we work from inner->outer in a loop nest we call
7894      find_loop_nodes_find which will increment loop_depth for nodes
7895      within the current loop, which happens to enclose inner loops.  */
7896
7897   num_loops = 0;
7898   for (b = 0; b < n_basic_blocks; b++)
7899     {
7900       BASIC_BLOCK (b)->loop_depth = 0;
7901       for (e = BASIC_BLOCK (b)->pred; e; e = e->pred_next)
7902         {
7903           basic_block latch = e->src;
7904
7905           /* Look for back edges where a predecessor is dominated
7906              by this block.  A natural loop has a single entry
7907              node (header) that dominates all the nodes in the
7908              loop.  It also has single back edge to the header
7909              from a latch node.  Note that multiple natural loops
7910              may share the same header.  */
7911           if (latch != ENTRY_BLOCK_PTR && TEST_BIT (dom[latch->index], b))
7912             num_loops++;
7913         }
7914     }
7915
7916   if (num_loops)
7917     {
7918       /* Compute depth first search order of the CFG so that outer
7919          natural loops will be found before inner natural loops.  */
7920       dfs_order = (int *) xmalloc (n_basic_blocks * sizeof (int));
7921       rc_order = (int *) xmalloc (n_basic_blocks * sizeof (int));
7922       flow_depth_first_order_compute (dfs_order, rc_order);
7923
7924       /* Allocate loop structures.  */
7925       loops->array
7926         = (struct loop *) xcalloc (num_loops, sizeof (struct loop));
7927
7928       headers = sbitmap_alloc (n_basic_blocks);
7929       sbitmap_zero (headers);
7930
7931       loops->shared_headers = sbitmap_alloc (n_basic_blocks);
7932       sbitmap_zero (loops->shared_headers);
7933
7934       /* Find and record information about all the natural loops
7935          in the CFG.  */
7936       num_loops = 0;
7937       for (b = 0; b < n_basic_blocks; b++)
7938         {
7939           basic_block header;
7940
7941           /* Search the nodes of the CFG in DFS order that we can find
7942              outer loops first.  */
7943           header = BASIC_BLOCK (rc_order[b]);
7944
7945           /* Look for all the possible latch blocks for this header.  */
7946           for (e = header->pred; e; e = e->pred_next)
7947             {
7948               basic_block latch = e->src;
7949
7950               /* Look for back edges where a predecessor is dominated
7951                  by this block.  A natural loop has a single entry
7952                  node (header) that dominates all the nodes in the
7953                  loop.  It also has single back edge to the header
7954                  from a latch node.  Note that multiple natural loops
7955                  may share the same header.  */
7956               if (latch != ENTRY_BLOCK_PTR
7957                   && TEST_BIT (dom[latch->index], header->index))
7958                 {
7959                   struct loop *loop;
7960
7961                   loop = loops->array + num_loops;
7962
7963                   loop->header = header;
7964                   loop->latch = latch;
7965                   loop->num = num_loops;
7966
7967                   /* Keep track of blocks that are loop headers so
7968                      that we can tell which loops should be merged.  */
7969                   if (TEST_BIT (headers, header->index))
7970                     SET_BIT (loops->shared_headers, header->index);
7971                   SET_BIT (headers, header->index);
7972
7973                   /* Find nodes contained within the loop.  */
7974                   loop->nodes = sbitmap_alloc (n_basic_blocks);
7975                   loop->num_nodes
7976                     = flow_loop_nodes_find (header, latch, loop->nodes);
7977
7978                   /* Compute first and last blocks within the loop.
7979                      These are often the same as the loop header and
7980                      loop latch respectively, but this is not always
7981                      the case.  */
7982                   loop->first
7983                     = BASIC_BLOCK (sbitmap_first_set_bit (loop->nodes));
7984                   loop->last
7985                     = BASIC_BLOCK (sbitmap_last_set_bit (loop->nodes));
7986
7987                   /* Find edges which enter the loop header.
7988                      Note that the entry edges should only
7989                      enter the header of a natural loop.  */
7990                   loop->num_entries
7991                     = flow_loop_entry_edges_find (loop->header, loop->nodes,
7992                                                   &loop->entry_edges);
7993
7994                   /* Find edges which exit the loop.  */
7995                   loop->num_exits
7996                     = flow_loop_exit_edges_find (loop->nodes,
7997                                                  &loop->exit_edges);
7998
7999                   /* Look to see if the loop has a pre-header node.  */
8000                   loop->pre_header = flow_loop_pre_header_find (header, dom);
8001
8002                   num_loops++;
8003                 }
8004             }
8005         }
8006
8007       /* Natural loops with shared headers may either be disjoint or
8008          nested.  Disjoint loops with shared headers cannot be inner
8009          loops and should be merged.  For now just mark loops that share
8010          headers.  */
8011       for (i = 0; i < num_loops; i++)
8012         if (TEST_BIT (loops->shared_headers, loops->array[i].header->index))
8013           loops->array[i].shared = 1;
8014
8015       sbitmap_free (headers);
8016     }
8017
8018   loops->num = num_loops;
8019
8020   /* Save CFG derived information to avoid recomputing it.  */
8021   loops->cfg.dom = dom;
8022   loops->cfg.dfs_order = dfs_order;
8023   loops->cfg.rc_order = rc_order;
8024
8025   /* Build the loop hierarchy tree.  */
8026   flow_loops_tree_build (loops);
8027
8028   /* Assign the loop nesting depth and enclosed loop level for each
8029      loop.  */
8030   loops->levels = flow_loops_level_compute (loops);
8031
8032   return num_loops;
8033 }
8034
8035 /* Return non-zero if edge E enters header of LOOP from outside of LOOP.  */
8036
8037 int
8038 flow_loop_outside_edge_p (loop, e)
8039      const struct loop *loop;
8040      edge e;
8041 {
8042   if (e->dest != loop->header)
8043     abort ();
8044   return (e->src == ENTRY_BLOCK_PTR)
8045     || ! TEST_BIT (loop->nodes, e->src->index);
8046 }
8047
8048 /* Clear LOG_LINKS fields of insns in a chain.
8049    Also clear the global_live_at_{start,end} fields of the basic block
8050    structures.  */
8051
8052 void
8053 clear_log_links (insns)
8054      rtx insns;
8055 {
8056   rtx i;
8057   int b;
8058
8059   for (i = insns; i; i = NEXT_INSN (i))
8060     if (INSN_P (i))
8061       LOG_LINKS (i) = 0;
8062
8063   for (b = 0; b < n_basic_blocks; b++)
8064     {
8065       basic_block bb = BASIC_BLOCK (b);
8066
8067       bb->global_live_at_start = NULL;
8068       bb->global_live_at_end = NULL;
8069     }
8070
8071   ENTRY_BLOCK_PTR->global_live_at_end = NULL;
8072   EXIT_BLOCK_PTR->global_live_at_start = NULL;
8073 }
8074
8075 /* Given a register bitmap, turn on the bits in a HARD_REG_SET that
8076    correspond to the hard registers, if any, set in that map.  This
8077    could be done far more efficiently by having all sorts of special-cases
8078    with moving single words, but probably isn't worth the trouble.  */
8079
8080 void
8081 reg_set_to_hard_reg_set (to, from)
8082      HARD_REG_SET *to;
8083      bitmap from;
8084 {
8085   int i;
8086
8087   EXECUTE_IF_SET_IN_BITMAP
8088     (from, 0, i,
8089      {
8090        if (i >= FIRST_PSEUDO_REGISTER)
8091          return;
8092        SET_HARD_REG_BIT (*to, i);
8093      });
8094 }