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