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