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