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