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