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