gcc/flow.c

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