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