gcc/flow.c

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