gcc/flow.c

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