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,
3768                                   REG_NOTES (insn));
3769       libcall_is_dead = (insn_is_dead && note != 0
3770                          && libcall_dead_p (pbi, note, insn));
3771     }
3772
3773   /* We almost certainly don't want to delete prologue or epilogue
3774      instructions.  Warn about probable compiler losage.  */
3775   if (insn_is_dead
3776       && reload_completed
3777       && (((HAVE_epilogue || HAVE_prologue)
3778            && prologue_epilogue_contains (insn))
3779           || (HAVE_sibcall_epilogue
3780               && sibcall_epilogue_contains (insn)))
3781       && find_reg_note (insn, REG_MAYBE_DEAD, NULL_RTX) == 0)
3782     {
3783       if (flags & PROP_KILL_DEAD_CODE)
3784         {
3785           warning ("ICE: would have deleted prologue/epilogue insn");
3786           if (!inhibit_warnings)
3787             debug_rtx (insn);
3788         }
3789       libcall_is_dead = insn_is_dead = 0;
3790     }
3791
3792   /* If an instruction consists of just dead store(s) on final pass,
3793      delete it.  */
3794   if ((flags & PROP_KILL_DEAD_CODE) && insn_is_dead)
3795     {
3796       /* Record sets.  Do this even for dead instructions, since they
3797          would have killed the values if they hadn't been deleted.  */
3798       mark_set_regs (pbi, PATTERN (insn), insn);
3799
3800       /* CC0 is now known to be dead.  Either this insn used it,
3801          in which case it doesn't anymore, or clobbered it,
3802          so the next insn can't use it.  */
3803       pbi->cc0_live = 0;
3804
3805       if (libcall_is_dead)
3806         {
3807           prev = propagate_block_delete_libcall (pbi->bb, insn, note);
3808           insn = NEXT_INSN (prev);
3809         }
3810       else
3811         propagate_block_delete_insn (pbi->bb, insn);
3812
3813       return prev;
3814     }
3815
3816   /* See if this is an increment or decrement that can be merged into
3817      a following memory address.  */
3818 #ifdef AUTO_INC_DEC
3819   {
3820     register rtx x = single_set (insn);
3821
3822     /* Does this instruction increment or decrement a register?  */
3823     if ((flags & PROP_AUTOINC)
3824         && x != 0
3825         && GET_CODE (SET_DEST (x)) == REG
3826         && (GET_CODE (SET_SRC (x)) == PLUS
3827             || GET_CODE (SET_SRC (x)) == MINUS)
3828         && XEXP (SET_SRC (x), 0) == SET_DEST (x)
3829         && GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
3830         /* Ok, look for a following memory ref we can combine with.
3831            If one is found, change the memory ref to a PRE_INC
3832            or PRE_DEC, cancel this insn, and return 1.
3833            Return 0 if nothing has been done.  */
3834         && try_pre_increment_1 (pbi, insn))
3835       return prev;
3836   }
3837 #endif /* AUTO_INC_DEC */
3838
3839   CLEAR_REG_SET (pbi->new_set);
3840
3841   /* If this is not the final pass, and this insn is copying the value of
3842      a library call and it's dead, don't scan the insns that perform the
3843      library call, so that the call's arguments are not marked live.  */
3844   if (libcall_is_dead)
3845     {
3846       /* Record the death of the dest reg.  */
3847       mark_set_regs (pbi, PATTERN (insn), insn);
3848
3849       insn = XEXP (note, 0);
3850       return PREV_INSN (insn);
3851     }
3852   else if (GET_CODE (PATTERN (insn)) == SET
3853            && SET_DEST (PATTERN (insn)) == stack_pointer_rtx
3854            && GET_CODE (SET_SRC (PATTERN (insn))) == PLUS
3855            && XEXP (SET_SRC (PATTERN (insn)), 0) == stack_pointer_rtx
3856            && GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 1)) == CONST_INT)
3857     /* We have an insn to pop a constant amount off the stack.
3858        (Such insns use PLUS regardless of the direction of the stack,
3859        and any insn to adjust the stack by a constant is always a pop.)
3860        These insns, if not dead stores, have no effect on life.  */
3861     ;
3862   else
3863     {
3864       /* Any regs live at the time of a call instruction must not go
3865          in a register clobbered by calls.  Find all regs now live and
3866          record this for them.  */
3867
3868       if (GET_CODE (insn) == CALL_INSN && (flags & PROP_REG_INFO))
3869         EXECUTE_IF_SET_IN_REG_SET (pbi->reg_live, 0, i,
3870                                    { REG_N_CALLS_CROSSED (i)++; });
3871
3872       /* Record sets.  Do this even for dead instructions, since they
3873          would have killed the values if they hadn't been deleted.  */
3874       mark_set_regs (pbi, PATTERN (insn), insn);
3875
3876       if (GET_CODE (insn) == CALL_INSN)
3877         {
3878           register int i;
3879           rtx note, cond;
3880
3881           cond = NULL_RTX;
3882           if (GET_CODE (PATTERN (insn)) == COND_EXEC)
3883             cond = COND_EXEC_TEST (PATTERN (insn));
3884
3885           /* Non-constant calls clobber memory.  */
3886           if (! CONST_CALL_P (insn))
3887             {
3888               free_EXPR_LIST_list (&pbi->mem_set_list);
3889               pbi->mem_set_list_len = 0;
3890             }
3891
3892           /* There may be extra registers to be clobbered.  */
3893           for (note = CALL_INSN_FUNCTION_USAGE (insn);
3894                note;
3895                note = XEXP (note, 1))
3896             if (GET_CODE (XEXP (note, 0)) == CLOBBER)
3897               mark_set_1 (pbi, CLOBBER, XEXP (XEXP (note, 0), 0),
3898                           cond, insn, pbi->flags);
3899
3900           /* Calls change all call-used and global registers.  */
3901           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3902             if (call_used_regs[i] && ! global_regs[i]
3903                 && ! fixed_regs[i])
3904               {
3905                 /* We do not want REG_UNUSED notes for these registers.  */
3906                 mark_set_1 (pbi, CLOBBER, gen_rtx_REG (reg_raw_mode[i], i),
3907                             cond, insn,
3908                             pbi->flags & ~(PROP_DEATH_NOTES | PROP_REG_INFO));
3909               }
3910         }
3911
3912       /* If an insn doesn't use CC0, it becomes dead since we assume
3913          that every insn clobbers it.  So show it dead here;
3914          mark_used_regs will set it live if it is referenced.  */
3915       pbi->cc0_live = 0;
3916
3917       /* Record uses.  */
3918       if (! insn_is_dead)
3919         mark_used_regs (pbi, PATTERN (insn), NULL_RTX, insn);
3920
3921       /* Sometimes we may have inserted something before INSN (such as a move)
3922          when we make an auto-inc.  So ensure we will scan those insns.  */
3923 #ifdef AUTO_INC_DEC
3924       prev = PREV_INSN (insn);
3925 #endif
3926
3927       if (! insn_is_dead && GET_CODE (insn) == CALL_INSN)
3928         {
3929           register int i;
3930           rtx note, cond;
3931
3932           cond = NULL_RTX;
3933           if (GET_CODE (PATTERN (insn)) == COND_EXEC)
3934             cond = COND_EXEC_TEST (PATTERN (insn));
3935
3936           /* Calls use their arguments.  */
3937           for (note = CALL_INSN_FUNCTION_USAGE (insn);
3938                note;
3939                note = XEXP (note, 1))
3940             if (GET_CODE (XEXP (note, 0)) == USE)
3941               mark_used_regs (pbi, XEXP (XEXP (note, 0), 0),
3942                               cond, insn);
3943
3944           /* The stack ptr is used (honorarily) by a CALL insn.  */
3945           SET_REGNO_REG_SET (pbi->reg_live, STACK_POINTER_REGNUM);
3946
3947           /* Calls may also reference any of the global registers,
3948              so they are made live.  */
3949           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3950             if (global_regs[i])
3951               mark_used_reg (pbi, gen_rtx_REG (reg_raw_mode[i], i),
3952                              cond, insn);
3953         }
3954     }
3955
3956   /* On final pass, update counts of how many insns in which each reg
3957      is live.  */
3958   if (flags & PROP_REG_INFO)
3959     EXECUTE_IF_SET_IN_REG_SET (pbi->reg_live, 0, i,
3960                                { REG_LIVE_LENGTH (i)++; });
3961
3962   return prev;
3963 }
3964
3965 /* Initialize a propagate_block_info struct for public consumption.
3966    Note that the structure itself is opaque to this file, but that
3967    the user can use the regsets provided here.  */
3968
3969 struct propagate_block_info *
3970 init_propagate_block_info (bb, live, local_set, cond_local_set, flags)
3971      basic_block bb;
3972      regset live, local_set, cond_local_set;
3973      int flags;
3974 {
3975   struct propagate_block_info *pbi = xmalloc (sizeof (*pbi));
3976
3977   pbi->bb = bb;
3978   pbi->reg_live = live;
3979   pbi->mem_set_list = NULL_RTX;
3980   pbi->mem_set_list_len = 0;
3981   pbi->local_set = local_set;
3982   pbi->cond_local_set = cond_local_set;
3983   pbi->cc0_live = 0;
3984   pbi->flags = flags;
3985
3986   if (flags & (PROP_LOG_LINKS | PROP_AUTOINC))
3987     pbi->reg_next_use = (rtx *) xcalloc (max_reg_num (), sizeof (rtx));
3988   else
3989     pbi->reg_next_use = NULL;
3990
3991   pbi->new_set = BITMAP_XMALLOC ();
3992
3993 #ifdef HAVE_conditional_execution
3994   pbi->reg_cond_dead = splay_tree_new (splay_tree_compare_ints, NULL,
3995                                        free_reg_cond_life_info);
3996   pbi->reg_cond_reg = BITMAP_XMALLOC ();
3997
3998   /* If this block ends in a conditional branch, for each register live
3999      from one side of the branch and not the other, record the register
4000      as conditionally dead.  */
4001   if (GET_CODE (bb->end) == JUMP_INSN
4002       && any_condjump_p (bb->end))
4003     {
4004       regset_head diff_head;
4005       regset diff = INITIALIZE_REG_SET (diff_head);
4006       basic_block bb_true, bb_false;
4007       rtx cond_true, cond_false, set_src;
4008       int i;
4009
4010       /* Identify the successor blocks.  */
4011       bb_true = bb->succ->dest;
4012       if (bb->succ->succ_next != NULL)
4013         {
4014           bb_false = bb->succ->succ_next->dest;
4015
4016           if (bb->succ->flags & EDGE_FALLTHRU)
4017             {
4018               basic_block t = bb_false;
4019               bb_false = bb_true;
4020               bb_true = t;
4021             }
4022           else if (! (bb->succ->succ_next->flags & EDGE_FALLTHRU))
4023             abort ();
4024         }
4025       else
4026         {
4027           /* This can happen with a conditional jump to the next insn.  */
4028           if (JUMP_LABEL (bb->end) != bb_true->head)
4029             abort ();
4030
4031           /* Simplest way to do nothing.  */
4032           bb_false = bb_true;
4033         }
4034
4035       /* Extract the condition from the branch.  */
4036       set_src = SET_SRC (pc_set (bb->end));
4037       cond_true = XEXP (set_src, 0);
4038       cond_false = gen_rtx_fmt_ee (reverse_condition (GET_CODE (cond_true)),
4039                                    GET_MODE (cond_true), XEXP (cond_true, 0),
4040                                    XEXP (cond_true, 1));
4041       if (GET_CODE (XEXP (set_src, 1)) == PC)
4042         {
4043           rtx t = cond_false;
4044           cond_false = cond_true;
4045           cond_true = t;
4046         }
4047
4048       /* Compute which register lead different lives in the successors.  */
4049       if (bitmap_operation (diff, bb_true->global_live_at_start,
4050                             bb_false->global_live_at_start, BITMAP_XOR))
4051         {
4052           rtx reg = XEXP (cond_true, 0);
4053
4054           if (GET_CODE (reg) == SUBREG)
4055             reg = SUBREG_REG (reg);
4056
4057           if (GET_CODE (reg) != REG)
4058             abort ();
4059
4060           SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (reg));
4061
4062           /* For each such register, mark it conditionally dead.  */
4063           EXECUTE_IF_SET_IN_REG_SET
4064             (diff, 0, i,
4065              {
4066                struct reg_cond_life_info *rcli;
4067                rtx cond;
4068
4069                rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
4070
4071                if (REGNO_REG_SET_P (bb_true->global_live_at_start, i))
4072                  cond = cond_false;
4073                else
4074                  cond = cond_true;
4075                rcli->condition = cond;
4076
4077                splay_tree_insert (pbi->reg_cond_dead, i,
4078                                   (splay_tree_value) rcli);
4079              });
4080         }
4081
4082       FREE_REG_SET (diff);
4083     }
4084 #endif
4085
4086   /* If this block has no successors, any stores to the frame that aren't
4087      used later in the block are dead.  So make a pass over the block
4088      recording any such that are made and show them dead at the end.  We do
4089      a very conservative and simple job here.  */
4090   if (optimize
4091       && ! (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE
4092             && (TYPE_RETURNS_STACK_DEPRESSED
4093                 (TREE_TYPE (current_function_decl))))
4094       && (flags & PROP_SCAN_DEAD_CODE)
4095       && (bb->succ == NULL
4096           || (bb->succ->succ_next == NULL
4097               && bb->succ->dest == EXIT_BLOCK_PTR)))
4098     {
4099       rtx insn;
4100       for (insn = bb->end; insn != bb->head; insn = PREV_INSN (insn))
4101         if (GET_CODE (insn) == INSN
4102             && GET_CODE (PATTERN (insn)) == SET
4103             && GET_CODE (SET_DEST (PATTERN (insn))) == MEM)
4104           {
4105             rtx mem = SET_DEST (PATTERN (insn));
4106
4107             if (XEXP (mem, 0) == frame_pointer_rtx
4108                 || (GET_CODE (XEXP (mem, 0)) == PLUS
4109                     && XEXP (XEXP (mem, 0), 0) == frame_pointer_rtx
4110                     && GET_CODE (XEXP (XEXP (mem, 0), 1)) == CONST_INT))
4111               {
4112 #ifdef AUTO_INC_DEC
4113                 /* Store a copy of mem, otherwise the address may be scrogged
4114                    by find_auto_inc.  This matters because insn_dead_p uses
4115                    an rtx_equal_p check to determine if two addresses are
4116                    the same.  This works before find_auto_inc, but fails
4117                    after find_auto_inc, causing discrepencies between the
4118                    set of live registers calculated during the
4119                    calculate_global_regs_live phase and what actually exists
4120                    after flow completes, leading to aborts.  */
4121                 if (flags & PROP_AUTOINC)
4122                   mem = shallow_copy_rtx (mem);
4123 #endif
4124                 pbi->mem_set_list = alloc_EXPR_LIST (0, mem, pbi->mem_set_list);
4125                 if (++pbi->mem_set_list_len >= MAX_MEM_SET_LIST_LEN)
4126                   break;
4127               }
4128           }
4129     }
4130
4131   return pbi;
4132 }
4133
4134 /* Release a propagate_block_info struct.  */
4135
4136 void
4137 free_propagate_block_info (pbi)
4138      struct propagate_block_info *pbi;
4139 {
4140   free_EXPR_LIST_list (&pbi->mem_set_list);
4141
4142   BITMAP_XFREE (pbi->new_set);
4143
4144 #ifdef HAVE_conditional_execution
4145   splay_tree_delete (pbi->reg_cond_dead);
4146   BITMAP_XFREE (pbi->reg_cond_reg);
4147 #endif
4148
4149   if (pbi->reg_next_use)
4150     free (pbi->reg_next_use);
4151
4152   free (pbi);
4153 }
4154
4155 /* Compute the registers live at the beginning of a basic block BB from
4156    those live at the end.
4157
4158    When called, REG_LIVE contains those live at the end.  On return, it
4159    contains those live at the beginning.
4160
4161    LOCAL_SET, if non-null, will be set with all registers killed
4162    unconditionally by this basic block.
4163    Likewise, COND_LOCAL_SET, if non-null, will be set with all registers
4164    killed conditionally by this basic block.  If there is any unconditional
4165    set of a register, then the corresponding bit will be set in LOCAL_SET
4166    and cleared in COND_LOCAL_SET.
4167    It is valid for LOCAL_SET and COND_LOCAL_SET to be the same set.  In this
4168    case, the resulting set will be equal to the union of the two sets that
4169    would otherwise be computed.  */
4170
4171 void
4172 propagate_block (bb, live, local_set, cond_local_set, flags)
4173      basic_block bb;
4174      regset live;
4175      regset local_set;
4176      regset cond_local_set;
4177      int flags;
4178 {
4179   struct propagate_block_info *pbi;
4180   rtx insn, prev;
4181
4182   pbi = init_propagate_block_info (bb, live, local_set, cond_local_set, flags);
4183
4184   if (flags & PROP_REG_INFO)
4185     {
4186       register int i;
4187
4188       /* Process the regs live at the end of the block.
4189          Mark them as not local to any one basic block.  */
4190       EXECUTE_IF_SET_IN_REG_SET (live, 0, i,
4191                                  { REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL; });
4192     }
4193
4194   /* Scan the block an insn at a time from end to beginning.  */
4195
4196   for (insn = bb->end;; insn = prev)
4197     {
4198       /* If this is a call to `setjmp' et al, warn if any
4199          non-volatile datum is live.  */
4200       if ((flags & PROP_REG_INFO)
4201           && GET_CODE (insn) == NOTE
4202           && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
4203         IOR_REG_SET (regs_live_at_setjmp, pbi->reg_live);
4204
4205       prev = propagate_one_insn (pbi, insn);
4206
4207       if (insn == bb->head)
4208         break;
4209     }
4210
4211   free_propagate_block_info (pbi);
4212 }
4213 \f
4214 /* Return 1 if X (the body of an insn, or part of it) is just dead stores
4215    (SET expressions whose destinations are registers dead after the insn).
4216    NEEDED is the regset that says which regs are alive after the insn.
4217
4218    Unless CALL_OK is non-zero, an insn is needed if it contains a CALL.
4219
4220    If X is the entire body of an insn, NOTES contains the reg notes
4221    pertaining to the insn.  */
4222
4223 static int
4224 insn_dead_p (pbi, x, call_ok, notes)
4225      struct propagate_block_info *pbi;
4226      rtx x;
4227      int call_ok;
4228      rtx notes ATTRIBUTE_UNUSED;
4229 {
4230   enum rtx_code code = GET_CODE (x);
4231
4232 #ifdef AUTO_INC_DEC
4233   /* If flow is invoked after reload, we must take existing AUTO_INC
4234      expresions into account.  */
4235   if (reload_completed)
4236     {
4237       for (; notes; notes = XEXP (notes, 1))
4238         {
4239           if (REG_NOTE_KIND (notes) == REG_INC)
4240             {
4241               int regno = REGNO (XEXP (notes, 0));
4242
4243               /* Don't delete insns to set global regs.  */
4244               if ((regno < FIRST_PSEUDO_REGISTER && global_regs[regno])
4245                   || REGNO_REG_SET_P (pbi->reg_live, regno))
4246                 return 0;
4247             }
4248         }
4249     }
4250 #endif
4251
4252   /* If setting something that's a reg or part of one,
4253      see if that register's altered value will be live.  */
4254
4255   if (code == SET)
4256     {
4257       rtx r = SET_DEST (x);
4258
4259 #ifdef HAVE_cc0
4260       if (GET_CODE (r) == CC0)
4261         return ! pbi->cc0_live;
4262 #endif
4263
4264       /* A SET that is a subroutine call cannot be dead.  */
4265       if (GET_CODE (SET_SRC (x)) == CALL)
4266         {
4267           if (! call_ok)
4268             return 0;
4269         }
4270
4271       /* Don't eliminate loads from volatile memory or volatile asms.  */
4272       else if (volatile_refs_p (SET_SRC (x)))
4273         return 0;
4274
4275       if (GET_CODE (r) == MEM)
4276         {
4277           rtx temp;
4278
4279           if (MEM_VOLATILE_P (r))
4280             return 0;
4281
4282           /* Walk the set of memory locations we are currently tracking
4283              and see if one is an identical match to this memory location.
4284              If so, this memory write is dead (remember, we're walking
4285              backwards from the end of the block to the start).  */
4286           temp = pbi->mem_set_list;
4287           while (temp)
4288             {
4289               rtx mem = XEXP (temp, 0);
4290
4291               if (rtx_equal_p (mem, r))
4292                 return 1;
4293 #ifdef AUTO_INC_DEC
4294               /* Check if memory reference matches an auto increment. Only
4295                  post increment/decrement or modify are valid.  */
4296               if (GET_MODE (mem) == GET_MODE (r)
4297                   && (GET_CODE (XEXP (mem, 0)) == POST_DEC
4298                       || GET_CODE (XEXP (mem, 0)) == POST_INC
4299                       || GET_CODE (XEXP (mem, 0)) == POST_MODIFY)
4300                   && GET_MODE (XEXP (mem, 0)) == GET_MODE (r)
4301                   && rtx_equal_p (XEXP (XEXP (mem, 0), 0), XEXP (r, 0)))
4302                 return 1;
4303 #endif
4304               temp = XEXP (temp, 1);
4305             }
4306         }
4307       else
4308         {
4309           while (GET_CODE (r) == SUBREG
4310                  || GET_CODE (r) == STRICT_LOW_PART
4311                  || GET_CODE (r) == ZERO_EXTRACT)
4312             r = XEXP (r, 0);
4313
4314           if (GET_CODE (r) == REG)
4315             {
4316               int regno = REGNO (r);
4317
4318               /* Obvious.  */
4319               if (REGNO_REG_SET_P (pbi->reg_live, regno))
4320                 return 0;
4321
4322               /* If this is a hard register, verify that subsequent
4323                  words are not needed.  */
4324               if (regno < FIRST_PSEUDO_REGISTER)
4325                 {
4326                   int n = HARD_REGNO_NREGS (regno, GET_MODE (r));
4327
4328                   while (--n > 0)
4329                     if (REGNO_REG_SET_P (pbi->reg_live, regno+n))
4330                       return 0;
4331                 }
4332
4333               /* Don't delete insns to set global regs.  */
4334               if (regno < FIRST_PSEUDO_REGISTER && global_regs[regno])
4335                 return 0;
4336
4337               /* Make sure insns to set the stack pointer aren't deleted.  */
4338               if (regno == STACK_POINTER_REGNUM)
4339                 return 0;
4340
4341               /* ??? These bits might be redundant with the force live bits
4342                  in calculate_global_regs_live.  We would delete from
4343                  sequential sets; whether this actually affects real code
4344                  for anything but the stack pointer I don't know.  */
4345               /* Make sure insns to set the frame pointer aren't deleted.  */
4346               if (regno == FRAME_POINTER_REGNUM
4347                   && (! reload_completed || frame_pointer_needed))
4348                 return 0;
4349 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
4350               if (regno == HARD_FRAME_POINTER_REGNUM
4351                   && (! reload_completed || frame_pointer_needed))
4352                 return 0;
4353 #endif
4354
4355 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4356               /* Make sure insns to set arg pointer are never deleted
4357                  (if the arg pointer isn't fixed, there will be a USE
4358                  for it, so we can treat it normally).  */
4359               if (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
4360                 return 0;
4361 #endif
4362
4363               /* Otherwise, the set is dead.  */
4364               return 1;
4365             }
4366         }
4367     }
4368
4369   /* If performing several activities, insn is dead if each activity
4370      is individually dead.  Also, CLOBBERs and USEs can be ignored; a
4371      CLOBBER or USE that's inside a PARALLEL doesn't make the insn
4372      worth keeping.  */
4373   else if (code == PARALLEL)
4374     {
4375       int i = XVECLEN (x, 0);
4376
4377       for (i--; i >= 0; i--)
4378         if (GET_CODE (XVECEXP (x, 0, i)) != CLOBBER
4379             && GET_CODE (XVECEXP (x, 0, i)) != USE
4380             && ! insn_dead_p (pbi, XVECEXP (x, 0, i), call_ok, NULL_RTX))
4381           return 0;
4382
4383       return 1;
4384     }
4385
4386   /* A CLOBBER of a pseudo-register that is dead serves no purpose.  That
4387      is not necessarily true for hard registers.  */
4388   else if (code == CLOBBER && GET_CODE (XEXP (x, 0)) == REG
4389            && REGNO (XEXP (x, 0)) >= FIRST_PSEUDO_REGISTER
4390            && ! REGNO_REG_SET_P (pbi->reg_live, REGNO (XEXP (x, 0))))
4391     return 1;
4392
4393   /* We do not check other CLOBBER or USE here.  An insn consisting of just
4394      a CLOBBER or just a USE should not be deleted.  */
4395   return 0;
4396 }
4397
4398 /* If INSN is the last insn in a libcall, and assuming INSN is dead,
4399    return 1 if the entire library call is dead.
4400    This is true if INSN copies a register (hard or pseudo)
4401    and if the hard return reg of the call insn is dead.
4402    (The caller should have tested the destination of the SET inside
4403    INSN already for death.)
4404
4405    If this insn doesn't just copy a register, then we don't
4406    have an ordinary libcall.  In that case, cse could not have
4407    managed to substitute the source for the dest later on,
4408    so we can assume the libcall is dead.
4409
4410    PBI is the block info giving pseudoregs live before this insn.
4411    NOTE is the REG_RETVAL note of the insn.  */
4412
4413 static int
4414 libcall_dead_p (pbi, note, insn)
4415      struct propagate_block_info *pbi;
4416      rtx note;
4417      rtx insn;
4418 {
4419   rtx x = single_set (insn);
4420
4421   if (x)
4422     {
4423       register rtx r = SET_SRC (x);
4424       if (GET_CODE (r) == REG)
4425         {
4426           rtx call = XEXP (note, 0);
4427           rtx call_pat;
4428           register int i;
4429
4430           /* Find the call insn.  */
4431           while (call != insn && GET_CODE (call) != CALL_INSN)
4432             call = NEXT_INSN (call);
4433
4434           /* If there is none, do nothing special,
4435              since ordinary death handling can understand these insns.  */
4436           if (call == insn)
4437             return 0;
4438
4439           /* See if the hard reg holding the value is dead.
4440              If this is a PARALLEL, find the call within it.  */
4441           call_pat = PATTERN (call);
4442           if (GET_CODE (call_pat) == PARALLEL)
4443             {
4444               for (i = XVECLEN (call_pat, 0) - 1; i >= 0; i--)
4445                 if (GET_CODE (XVECEXP (call_pat, 0, i)) == SET
4446                     && GET_CODE (SET_SRC (XVECEXP (call_pat, 0, i))) == CALL)
4447                   break;
4448
4449               /* This may be a library call that is returning a value
4450                  via invisible pointer.  Do nothing special, since
4451                  ordinary death handling can understand these insns.  */
4452               if (i < 0)
4453                 return 0;
4454
4455               call_pat = XVECEXP (call_pat, 0, i);
4456             }
4457
4458           return insn_dead_p (pbi, call_pat, 1, REG_NOTES (call));
4459         }
4460     }
4461   return 1;
4462 }
4463
4464 /* Return 1 if register REGNO was used before it was set, i.e. if it is
4465    live at function entry.  Don't count global register variables, variables
4466    in registers that can be used for function arg passing, or variables in
4467    fixed hard registers.  */
4468
4469 int
4470 regno_uninitialized (regno)
4471      int regno;
4472 {
4473   if (n_basic_blocks == 0
4474       || (regno < FIRST_PSEUDO_REGISTER
4475           && (global_regs[regno]
4476               || fixed_regs[regno]
4477               || FUNCTION_ARG_REGNO_P (regno))))
4478     return 0;
4479
4480   return REGNO_REG_SET_P (BASIC_BLOCK (0)->global_live_at_start, regno);
4481 }
4482
4483 /* 1 if register REGNO was alive at a place where `setjmp' was called
4484    and was set more than once or is an argument.
4485    Such regs may be clobbered by `longjmp'.  */
4486
4487 int
4488 regno_clobbered_at_setjmp (regno)
4489      int regno;
4490 {
4491   if (n_basic_blocks == 0)
4492     return 0;
4493
4494   return ((REG_N_SETS (regno) > 1
4495            || REGNO_REG_SET_P (BASIC_BLOCK (0)->global_live_at_start, regno))
4496           && REGNO_REG_SET_P (regs_live_at_setjmp, regno));
4497 }
4498 \f
4499 /* INSN references memory, possibly using autoincrement addressing modes.
4500    Find any entries on the mem_set_list that need to be invalidated due
4501    to an address change.  */
4502
4503 static void
4504 invalidate_mems_from_autoinc (pbi, insn)
4505      struct propagate_block_info *pbi;
4506      rtx insn;
4507 {
4508   rtx note = REG_NOTES (insn);
4509   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
4510     {
4511       if (REG_NOTE_KIND (note) == REG_INC)
4512         {
4513           rtx temp = pbi->mem_set_list;
4514           rtx prev = NULL_RTX;
4515           rtx next;
4516
4517           while (temp)
4518             {
4519               next = XEXP (temp, 1);
4520               if (reg_overlap_mentioned_p (XEXP (note, 0), XEXP (temp, 0)))
4521                 {
4522                   /* Splice temp out of list.  */
4523                   if (prev)
4524                     XEXP (prev, 1) = next;
4525                   else
4526                     pbi->mem_set_list = next;
4527                   free_EXPR_LIST_node (temp);
4528                   pbi->mem_set_list_len--;
4529                 }
4530               else
4531                 prev = temp;
4532               temp = next;
4533             }
4534         }
4535     }
4536 }
4537
4538 /* EXP is either a MEM or a REG.  Remove any dependant entries
4539    from pbi->mem_set_list.  */
4540
4541 static void
4542 invalidate_mems_from_set (pbi, exp)
4543      struct propagate_block_info *pbi;
4544      rtx exp;
4545 {
4546   rtx temp = pbi->mem_set_list;
4547   rtx prev = NULL_RTX;
4548   rtx next;
4549
4550   while (temp)
4551     {
4552       next = XEXP (temp, 1);
4553       if ((GET_CODE (exp) == MEM
4554            && output_dependence (XEXP (temp, 0), exp))
4555           || (GET_CODE (exp) == REG
4556               && reg_overlap_mentioned_p (exp, XEXP (temp, 0))))
4557         {
4558           /* Splice this entry out of the list.  */
4559           if (prev)
4560             XEXP (prev, 1) = next;
4561           else
4562             pbi->mem_set_list = next;
4563           free_EXPR_LIST_node (temp);
4564           pbi->mem_set_list_len--;
4565         }
4566       else
4567         prev = temp;
4568       temp = next;
4569     }
4570 }
4571
4572 /* Process the registers that are set within X.  Their bits are set to
4573    1 in the regset DEAD, because they are dead prior to this insn.
4574
4575    If INSN is nonzero, it is the insn being processed.
4576
4577    FLAGS is the set of operations to perform.  */
4578
4579 static void
4580 mark_set_regs (pbi, x, insn)
4581      struct propagate_block_info *pbi;
4582      rtx x, insn;
4583 {
4584   rtx cond = NULL_RTX;
4585   rtx link;
4586   enum rtx_code code;
4587
4588   if (insn)
4589     for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
4590       {
4591         if (REG_NOTE_KIND (link) == REG_INC)
4592           mark_set_1 (pbi, SET, XEXP (link, 0),
4593                       (GET_CODE (x) == COND_EXEC
4594                        ? COND_EXEC_TEST (x) : NULL_RTX),
4595                       insn, pbi->flags);
4596       }
4597  retry:
4598   switch (code = GET_CODE (x))
4599     {
4600     case SET:
4601     case CLOBBER:
4602       mark_set_1 (pbi, code, SET_DEST (x), cond, insn, pbi->flags);
4603       return;
4604
4605     case COND_EXEC:
4606       cond = COND_EXEC_TEST (x);
4607       x = COND_EXEC_CODE (x);
4608       goto retry;
4609
4610     case PARALLEL:
4611       {
4612         register int i;
4613         for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
4614           {
4615             rtx sub = XVECEXP (x, 0, i);
4616             switch (code = GET_CODE (sub))
4617               {
4618               case COND_EXEC:
4619                 if (cond != NULL_RTX)
4620                   abort ();
4621
4622                 cond = COND_EXEC_TEST (sub);
4623                 sub = COND_EXEC_CODE (sub);
4624                 if (GET_CODE (sub) != SET && GET_CODE (sub) != CLOBBER)
4625                   break;
4626                 /* Fall through.  */
4627
4628               case SET:
4629               case CLOBBER:
4630                 mark_set_1 (pbi, code, SET_DEST (sub), cond, insn, pbi->flags);
4631                 break;
4632
4633               default:
4634                 break;
4635               }
4636           }
4637         break;
4638       }
4639
4640     default:
4641       break;
4642     }
4643 }
4644
4645 /* Process a single SET rtx, X.  */
4646
4647 static void
4648 mark_set_1 (pbi, code, reg, cond, insn, flags)
4649      struct propagate_block_info *pbi;
4650      enum rtx_code code;
4651      rtx reg, cond, insn;
4652      int flags;
4653 {
4654   int regno_first = -1, regno_last = -1;
4655   int not_dead = 0;
4656   int i;
4657
4658   /* Some targets place small structures in registers for
4659      return values of functions.  We have to detect this
4660      case specially here to get correct flow information.  */
4661   if (GET_CODE (reg) == PARALLEL
4662       && GET_MODE (reg) == BLKmode)
4663     {
4664       for (i = XVECLEN (reg, 0) - 1; i >= 0; i--)
4665         mark_set_1 (pbi, code, XVECEXP (reg, 0, i), cond, insn, flags);
4666       return;
4667     }
4668
4669   /* Modifying just one hardware register of a multi-reg value or just a
4670      byte field of a register does not mean the value from before this insn
4671      is now dead.  Of course, if it was dead after it's unused now.  */
4672
4673   switch (GET_CODE (reg))
4674     {
4675     case ZERO_EXTRACT:
4676     case SIGN_EXTRACT:
4677     case STRICT_LOW_PART:
4678       /* ??? Assumes STRICT_LOW_PART not used on multi-word registers.  */
4679       do
4680         reg = XEXP (reg, 0);
4681       while (GET_CODE (reg) == SUBREG
4682              || GET_CODE (reg) == ZERO_EXTRACT
4683              || GET_CODE (reg) == SIGN_EXTRACT
4684              || GET_CODE (reg) == STRICT_LOW_PART);
4685       if (GET_CODE (reg) == MEM)
4686         break;
4687       not_dead = REGNO_REG_SET_P (pbi->reg_live, REGNO (reg));
4688       /* Fall through.  */
4689
4690     case REG:
4691       regno_last = regno_first = REGNO (reg);
4692       if (regno_first < FIRST_PSEUDO_REGISTER)
4693         regno_last += HARD_REGNO_NREGS (regno_first, GET_MODE (reg)) - 1;
4694       break;
4695
4696     case SUBREG:
4697       if (GET_CODE (SUBREG_REG (reg)) == REG)
4698         {
4699           enum machine_mode outer_mode = GET_MODE (reg);
4700           enum machine_mode inner_mode = GET_MODE (SUBREG_REG (reg));
4701
4702           /* Identify the range of registers affected.  This is moderately
4703              tricky for hard registers.  See alter_subreg.  */
4704
4705           regno_last = regno_first = REGNO (SUBREG_REG (reg));
4706           if (regno_first < FIRST_PSEUDO_REGISTER)
4707             {
4708 #ifdef ALTER_HARD_SUBREG
4709               regno_first = ALTER_HARD_SUBREG (outer_mode, SUBREG_WORD (reg),
4710                                                inner_mode, regno_first);
4711 #else
4712               regno_first += SUBREG_WORD (reg);
4713 #endif
4714               regno_last = (regno_first
4715                             + HARD_REGNO_NREGS (regno_first, outer_mode) - 1);
4716
4717               /* Since we've just adjusted the register number ranges, make
4718                  sure REG matches.  Otherwise some_was_live will be clear
4719                  when it shouldn't have been, and we'll create incorrect
4720                  REG_UNUSED notes.  */
4721               reg = gen_rtx_REG (outer_mode, regno_first);
4722             }
4723           else
4724             {
4725               /* If the number of words in the subreg is less than the number
4726                  of words in the full register, we have a well-defined partial
4727                  set.  Otherwise the high bits are undefined.
4728
4729                  This is only really applicable to pseudos, since we just took
4730                  care of multi-word hard registers.  */
4731               if (((GET_MODE_SIZE (outer_mode)
4732                     + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
4733                   < ((GET_MODE_SIZE (inner_mode)
4734                       + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
4735                 not_dead = REGNO_REG_SET_P (pbi->reg_live, regno_first);
4736
4737               reg = SUBREG_REG (reg);
4738             }
4739         }
4740       else
4741         reg = SUBREG_REG (reg);
4742       break;
4743
4744     default:
4745       break;
4746     }
4747
4748   /* If this set is a MEM, then it kills any aliased writes.
4749      If this set is a REG, then it kills any MEMs which use the reg.  */
4750   if (optimize && (flags & PROP_SCAN_DEAD_CODE))
4751     {
4752       if (GET_CODE (reg) == MEM || GET_CODE (reg) == REG)
4753         invalidate_mems_from_set (pbi, reg);
4754
4755       /* If the memory reference had embedded side effects (autoincrement
4756          address modes.  Then we may need to kill some entries on the
4757          memory set list.  */
4758       if (insn && GET_CODE (reg) == MEM)
4759         invalidate_mems_from_autoinc (pbi, insn);
4760
4761       if (pbi->mem_set_list_len < MAX_MEM_SET_LIST_LEN
4762           && GET_CODE (reg) == MEM && ! side_effects_p (reg)
4763           /* ??? With more effort we could track conditional memory life.  */
4764           && ! cond
4765           /* We do not know the size of a BLKmode store, so we do not track
4766              them for redundant store elimination.  */
4767           && GET_MODE (reg) != BLKmode
4768           /* There are no REG_INC notes for SP, so we can't assume we'll see
4769              everything that invalidates it.  To be safe, don't eliminate any
4770              stores though SP; none of them should be redundant anyway.  */
4771           && ! reg_mentioned_p (stack_pointer_rtx, reg))
4772         {
4773 #ifdef AUTO_INC_DEC
4774           /* Store a copy of mem, otherwise the address may be
4775              scrogged by find_auto_inc.  */
4776           if (flags & PROP_AUTOINC)
4777             reg = shallow_copy_rtx (reg);
4778 #endif
4779           pbi->mem_set_list = alloc_EXPR_LIST (0, reg, pbi->mem_set_list);
4780           pbi->mem_set_list_len++;
4781         }
4782     }
4783
4784   if (GET_CODE (reg) == REG
4785       && ! (regno_first == FRAME_POINTER_REGNUM
4786             && (! reload_completed || frame_pointer_needed))
4787 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
4788       && ! (regno_first == HARD_FRAME_POINTER_REGNUM
4789             && (! reload_completed || frame_pointer_needed))
4790 #endif
4791 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
4792       && ! (regno_first == ARG_POINTER_REGNUM && fixed_regs[regno_first])
4793 #endif
4794       )
4795     {
4796       int some_was_live = 0, some_was_dead = 0;
4797
4798       for (i = regno_first; i <= regno_last; ++i)
4799         {
4800           int needed_regno = REGNO_REG_SET_P (pbi->reg_live, i);
4801           if (pbi->local_set)
4802             {
4803               /* Order of the set operation matters here since both
4804                  sets may be the same.  */
4805               CLEAR_REGNO_REG_SET (pbi->cond_local_set, i);
4806               if (cond != NULL_RTX
4807                   && ! REGNO_REG_SET_P (pbi->local_set, i))
4808                 SET_REGNO_REG_SET (pbi->cond_local_set, i);
4809               else
4810                 SET_REGNO_REG_SET (pbi->local_set, i);
4811             }
4812           if (code != CLOBBER)
4813             SET_REGNO_REG_SET (pbi->new_set, i);
4814
4815           some_was_live |= needed_regno;
4816           some_was_dead |= ! needed_regno;
4817         }
4818
4819 #ifdef HAVE_conditional_execution
4820       /* Consider conditional death in deciding that the register needs
4821          a death note.  */
4822       if (some_was_live && ! not_dead
4823           /* The stack pointer is never dead.  Well, not strictly true,
4824              but it's very difficult to tell from here.  Hopefully
4825              combine_stack_adjustments will fix up the most egregious
4826              errors.  */
4827           && regno_first != STACK_POINTER_REGNUM)
4828         {
4829           for (i = regno_first; i <= regno_last; ++i)
4830             if (! mark_regno_cond_dead (pbi, i, cond))
4831               not_dead = 1;
4832         }
4833 #endif
4834
4835       /* Additional data to record if this is the final pass.  */
4836       if (flags & (PROP_LOG_LINKS | PROP_REG_INFO
4837                    | PROP_DEATH_NOTES | PROP_AUTOINC))
4838         {
4839           register rtx y;
4840           register int blocknum = pbi->bb->index;
4841
4842           y = NULL_RTX;
4843           if (flags & (PROP_LOG_LINKS | PROP_AUTOINC))
4844             {
4845               y = pbi->reg_next_use[regno_first];
4846
4847               /* The next use is no longer next, since a store intervenes.  */
4848               for (i = regno_first; i <= regno_last; ++i)
4849                 pbi->reg_next_use[i] = 0;
4850             }
4851
4852           if (flags & PROP_REG_INFO)
4853             {
4854               for (i = regno_first; i <= regno_last; ++i)
4855                 {
4856                   /* Count (weighted) references, stores, etc.  This counts a
4857                      register twice if it is modified, but that is correct.  */
4858                   REG_N_SETS (i) += 1;
4859                   REG_N_REFS (i) += (optimize_size ? 1
4860                                      : pbi->bb->loop_depth + 1);
4861
4862                   /* The insns where a reg is live are normally counted
4863                      elsewhere, but we want the count to include the insn
4864                      where the reg is set, and the normal counting mechanism
4865                      would not count it.  */
4866                   REG_LIVE_LENGTH (i) += 1;
4867                 }
4868
4869               /* If this is a hard reg, record this function uses the reg.  */
4870               if (regno_first < FIRST_PSEUDO_REGISTER)
4871                 {
4872                   for (i = regno_first; i <= regno_last; i++)
4873                     regs_ever_live[i] = 1;
4874                 }
4875               else
4876                 {
4877                   /* Keep track of which basic blocks each reg appears in.  */
4878                   if (REG_BASIC_BLOCK (regno_first) == REG_BLOCK_UNKNOWN)
4879                     REG_BASIC_BLOCK (regno_first) = blocknum;
4880                   else if (REG_BASIC_BLOCK (regno_first) != blocknum)
4881                     REG_BASIC_BLOCK (regno_first) = REG_BLOCK_GLOBAL;
4882                 }
4883             }
4884
4885           if (! some_was_dead)
4886             {
4887               if (flags & PROP_LOG_LINKS)
4888                 {
4889                   /* Make a logical link from the next following insn
4890                      that uses this register, back to this insn.
4891                      The following insns have already been processed.
4892
4893                      We don't build a LOG_LINK for hard registers containing
4894                      in ASM_OPERANDs.  If these registers get replaced,
4895                      we might wind up changing the semantics of the insn,
4896                      even if reload can make what appear to be valid
4897                      assignments later.  */
4898                   if (y && (BLOCK_NUM (y) == blocknum)
4899                       && (regno_first >= FIRST_PSEUDO_REGISTER
4900                           || asm_noperands (PATTERN (y)) < 0))
4901                     LOG_LINKS (y) = alloc_INSN_LIST (insn, LOG_LINKS (y));
4902                 }
4903             }
4904           else if (not_dead)
4905             ;
4906           else if (! some_was_live)
4907             {
4908               if (flags & PROP_REG_INFO)
4909                 REG_N_DEATHS (regno_first) += 1;
4910
4911               if (flags & PROP_DEATH_NOTES)
4912                 {
4913                   /* Note that dead stores have already been deleted
4914                      when possible.  If we get here, we have found a
4915                      dead store that cannot be eliminated (because the
4916                      same insn does something useful).  Indicate this
4917                      by marking the reg being set as dying here.  */
4918                   REG_NOTES (insn)
4919                     = alloc_EXPR_LIST (REG_UNUSED, reg, REG_NOTES (insn));
4920                 }
4921             }
4922           else
4923             {
4924               if (flags & PROP_DEATH_NOTES)
4925                 {
4926                   /* This is a case where we have a multi-word hard register
4927                      and some, but not all, of the words of the register are
4928                      needed in subsequent insns.  Write REG_UNUSED notes
4929                      for those parts that were not needed.  This case should
4930                      be rare.  */
4931
4932                   for (i = regno_first; i <= regno_last; ++i)
4933                     if (! REGNO_REG_SET_P (pbi->reg_live, i))
4934                       REG_NOTES (insn)
4935                         = alloc_EXPR_LIST (REG_UNUSED,
4936                                            gen_rtx_REG (reg_raw_mode[i], i),
4937                                            REG_NOTES (insn));
4938                 }
4939             }
4940         }
4941
4942       /* Mark the register as being dead.  */
4943       if (some_was_live
4944           && ! not_dead
4945           /* The stack pointer is never dead.  Well, not strictly true,
4946              but it's very difficult to tell from here.  Hopefully
4947              combine_stack_adjustments will fix up the most egregious
4948              errors.  */
4949           && regno_first != STACK_POINTER_REGNUM)
4950         {
4951           for (i = regno_first; i <= regno_last; ++i)
4952             CLEAR_REGNO_REG_SET (pbi->reg_live, i);
4953         }
4954     }
4955   else if (GET_CODE (reg) == REG)
4956     {
4957       if (flags & (PROP_LOG_LINKS | PROP_AUTOINC))
4958         pbi->reg_next_use[regno_first] = 0;
4959     }
4960
4961   /* If this is the last pass and this is a SCRATCH, show it will be dying
4962      here and count it.  */
4963   else if (GET_CODE (reg) == SCRATCH)
4964     {
4965       if (flags & PROP_DEATH_NOTES)
4966         REG_NOTES (insn)
4967           = alloc_EXPR_LIST (REG_UNUSED, reg, REG_NOTES (insn));
4968     }
4969 }
4970 \f
4971 #ifdef HAVE_conditional_execution
4972 /* Mark REGNO conditionally dead.
4973    Return true if the register is now unconditionally dead.  */
4974
4975 static int
4976 mark_regno_cond_dead (pbi, regno, cond)
4977      struct propagate_block_info *pbi;
4978      int regno;
4979      rtx cond;
4980 {
4981   /* If this is a store to a predicate register, the value of the
4982      predicate is changing, we don't know that the predicate as seen
4983      before is the same as that seen after.  Flush all dependent
4984      conditions from reg_cond_dead.  This will make all such
4985      conditionally live registers unconditionally live.  */
4986   if (REGNO_REG_SET_P (pbi->reg_cond_reg, regno))
4987     flush_reg_cond_reg (pbi, regno);
4988
4989   /* If this is an unconditional store, remove any conditional
4990      life that may have existed.  */
4991   if (cond == NULL_RTX)
4992     splay_tree_remove (pbi->reg_cond_dead, regno);
4993   else
4994     {
4995       splay_tree_node node;
4996       struct reg_cond_life_info *rcli;
4997       rtx ncond;
4998
4999       /* Otherwise this is a conditional set.  Record that fact.
5000          It may have been conditionally used, or there may be a
5001          subsequent set with a complimentary condition.  */
5002
5003       node = splay_tree_lookup (pbi->reg_cond_dead, regno);
5004       if (node == NULL)
5005         {
5006           /* The register was unconditionally live previously.
5007              Record the current condition as the condition under
5008              which it is dead.  */
5009           rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
5010           rcli->condition = cond;
5011           splay_tree_insert (pbi->reg_cond_dead, regno,
5012                              (splay_tree_value) rcli);
5013
5014           SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
5015
5016           /* Not unconditionaly dead.  */
5017           return 0;
5018         }
5019       else
5020         {
5021           /* The register was conditionally live previously.
5022              Add the new condition to the old.  */
5023           rcli = (struct reg_cond_life_info *) node->value;
5024           ncond = rcli->condition;
5025           ncond = ior_reg_cond (ncond, cond, 1);
5026
5027           /* If the register is now unconditionally dead,
5028              remove the entry in the splay_tree.  */
5029           if (ncond == const1_rtx)
5030             splay_tree_remove (pbi->reg_cond_dead, regno);
5031           else
5032             {
5033               rcli->condition = ncond;
5034
5035               SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
5036
5037               /* Not unconditionaly dead.  */
5038               return 0;
5039             }
5040         }
5041     }
5042
5043   return 1;
5044 }
5045
5046 /* Called from splay_tree_delete for pbi->reg_cond_life.  */
5047
5048 static void
5049 free_reg_cond_life_info (value)
5050      splay_tree_value value;
5051 {
5052   struct reg_cond_life_info *rcli = (struct reg_cond_life_info *) value;
5053   free (rcli);
5054 }
5055
5056 /* Helper function for flush_reg_cond_reg.  */
5057
5058 static int
5059 flush_reg_cond_reg_1 (node, data)
5060      splay_tree_node node;
5061      void *data;
5062 {
5063   struct reg_cond_life_info *rcli;
5064   int *xdata = (int *) data;
5065   unsigned int regno = xdata[0];
5066
5067   /* Don't need to search if last flushed value was farther on in
5068      the in-order traversal.  */
5069   if (xdata[1] >= (int) node->key)
5070     return 0;
5071
5072   /* Splice out portions of the expression that refer to regno.  */
5073   rcli = (struct reg_cond_life_info *) node->value;
5074   rcli->condition = elim_reg_cond (rcli->condition, regno);
5075
5076   /* If the entire condition is now false, signal the node to be removed.  */
5077   if (rcli->condition == const0_rtx)
5078     {
5079       xdata[1] = node->key;
5080       return -1;
5081     }
5082   else if (rcli->condition == const1_rtx)
5083     abort ();
5084
5085   return 0;
5086 }
5087
5088 /* Flush all (sub) expressions referring to REGNO from REG_COND_LIVE.  */
5089
5090 static void
5091 flush_reg_cond_reg (pbi, regno)
5092      struct propagate_block_info *pbi;
5093      int regno;
5094 {
5095   int pair[2];
5096
5097   pair[0] = regno;
5098   pair[1] = -1;
5099   while (splay_tree_foreach (pbi->reg_cond_dead,
5100                              flush_reg_cond_reg_1, pair) == -1)
5101     splay_tree_remove (pbi->reg_cond_dead, pair[1]);
5102
5103   CLEAR_REGNO_REG_SET (pbi->reg_cond_reg, regno);
5104 }
5105
5106 /* Logical arithmetic on predicate conditions.  IOR, NOT and AND.
5107    For ior/and, the ADD flag determines whether we want to add the new
5108    condition X to the old one unconditionally.  If it is zero, we will
5109    only return a new expression if X allows us to simplify part of
5110    OLD, otherwise we return OLD unchanged to the caller.
5111    If ADD is nonzero, we will return a new condition in all cases.  The
5112    toplevel caller of one of these functions should always pass 1 for
5113    ADD.  */
5114
5115 static rtx
5116 ior_reg_cond (old, x, add)
5117      rtx old, x;
5118      int add;
5119 {
5120   rtx op0, op1;
5121
5122   if (GET_RTX_CLASS (GET_CODE (old)) == '<')
5123     {
5124       if (GET_RTX_CLASS (GET_CODE (x)) == '<'
5125           && GET_CODE (x) == reverse_condition (GET_CODE (old))
5126           && REGNO (XEXP (x, 0)) == REGNO (XEXP (old, 0)))
5127         return const1_rtx;
5128       if (GET_CODE (x) == GET_CODE (old)
5129           && REGNO (XEXP (x, 0)) == REGNO (XEXP (old, 0)))
5130         return old;
5131       if (! add)
5132         return old;
5133       return gen_rtx_IOR (0, old, x);
5134     }
5135
5136   switch (GET_CODE (old))
5137     {
5138     case IOR:
5139       op0 = ior_reg_cond (XEXP (old, 0), x, 0);
5140       op1 = ior_reg_cond (XEXP (old, 1), x, 0);
5141       if (op0 != XEXP (old, 0) || op1 != XEXP (old, 1))
5142         {
5143           if (op0 == const0_rtx)
5144             return op1;
5145           if (op1 == const0_rtx)
5146             return op0;
5147           if (op0 == const1_rtx || op1 == const1_rtx)
5148             return const1_rtx;
5149           if (op0 == XEXP (old, 0))
5150             op0 = gen_rtx_IOR (0, op0, x);
5151           else
5152             op1 = gen_rtx_IOR (0, op1, x);
5153           return gen_rtx_IOR (0, op0, op1);
5154         }
5155       if (! add)
5156         return old;
5157       return gen_rtx_IOR (0, old, x);
5158
5159     case AND:
5160       op0 = ior_reg_cond (XEXP (old, 0), x, 0);
5161       op1 = ior_reg_cond (XEXP (old, 1), x, 0);
5162       if (op0 != XEXP (old, 0) || op1 != XEXP (old, 1))
5163         {
5164           if (op0 == const1_rtx)
5165             return op1;
5166           if (op1 == const1_rtx)
5167             return op0;
5168           if (op0 == const0_rtx || op1 == const0_rtx)
5169             return const0_rtx;
5170           if (op0 == XEXP (old, 0))
5171             op0 = gen_rtx_IOR (0, op0, x);
5172           else
5173             op1 = gen_rtx_IOR (0, op1, x);
5174           return gen_rtx_AND (0, op0, op1);
5175         }
5176       if (! add)
5177         return old;
5178       return gen_rtx_IOR (0, old, x);
5179
5180     case NOT:
5181       op0 = and_reg_cond (XEXP (old, 0), not_reg_cond (x), 0);
5182       if (op0 != XEXP (old, 0))
5183         return not_reg_cond (op0);
5184       if (! add)
5185         return old;
5186       return gen_rtx_IOR (0, old, x);
5187
5188     default:
5189       abort ();
5190     }
5191 }
5192
5193 static rtx
5194 not_reg_cond (x)
5195      rtx x;
5196 {
5197   enum rtx_code x_code;
5198
5199   if (x == const0_rtx)
5200     return const1_rtx;
5201   else if (x == const1_rtx)
5202     return const0_rtx;
5203   x_code = GET_CODE (x);
5204   if (x_code == NOT)
5205     return XEXP (x, 0);
5206   if (GET_RTX_CLASS (x_code) == '<'
5207       && GET_CODE (XEXP (x, 0)) == REG)
5208     {
5209       if (XEXP (x, 1) != const0_rtx)
5210         abort ();
5211
5212       return gen_rtx_fmt_ee (reverse_condition (x_code),
5213                              VOIDmode, XEXP (x, 0), const0_rtx);
5214     }
5215   return gen_rtx_NOT (0, x);
5216 }
5217
5218 static rtx
5219 and_reg_cond (old, x, add)
5220      rtx old, x;
5221      int add;
5222 {
5223   rtx op0, op1;
5224
5225   if (GET_RTX_CLASS (GET_CODE (old)) == '<')
5226     {
5227       if (GET_RTX_CLASS (GET_CODE (x)) == '<'
5228           && GET_CODE (x) == reverse_condition (GET_CODE (old))
5229           && REGNO (XEXP (x, 0)) == REGNO (XEXP (old, 0)))
5230         return const0_rtx;
5231       if (GET_CODE (x) == GET_CODE (old)
5232           && REGNO (XEXP (x, 0)) == REGNO (XEXP (old, 0)))
5233         return old;
5234       if (! add)
5235         return old;
5236       return gen_rtx_AND (0, old, x);
5237     }
5238
5239   switch (GET_CODE (old))
5240     {
5241     case IOR:
5242       op0 = and_reg_cond (XEXP (old, 0), x, 0);
5243       op1 = and_reg_cond (XEXP (old, 1), x, 0);
5244       if (op0 != XEXP (old, 0) || op1 != XEXP (old, 1))
5245         {
5246           if (op0 == const0_rtx)
5247             return op1;
5248           if (op1 == const0_rtx)
5249             return op0;
5250           if (op0 == const1_rtx || op1 == const1_rtx)
5251             return const1_rtx;
5252           if (op0 == XEXP (old, 0))
5253             op0 = gen_rtx_AND (0, op0, x);
5254           else
5255             op1 = gen_rtx_AND (0, op1, x);
5256           return gen_rtx_IOR (0, op0, op1);
5257         }
5258       if (! add)
5259         return old;
5260       return gen_rtx_AND (0, old, x);
5261
5262     case AND:
5263       op0 = and_reg_cond (XEXP (old, 0), x, 0);
5264       op1 = and_reg_cond (XEXP (old, 1), x, 0);
5265       if (op0 != XEXP (old, 0) || op1 != XEXP (old, 1))
5266         {
5267           if (op0 == const1_rtx)
5268             return op1;
5269           if (op1 == const1_rtx)
5270             return op0;
5271           if (op0 == const0_rtx || op1 == const0_rtx)
5272             return const0_rtx;
5273           if (op0 == XEXP (old, 0))
5274             op0 = gen_rtx_AND (0, op0, x);
5275           else
5276             op1 = gen_rtx_AND (0, op1, x);
5277           return gen_rtx_AND (0, op0, op1);
5278         }
5279       if (! add)
5280         return old;
5281       return gen_rtx_AND (0, old, x);
5282
5283     case NOT:
5284       op0 = ior_reg_cond (XEXP (old, 0), not_reg_cond (x), 0);
5285       if (op0 != XEXP (old, 0))
5286         return not_reg_cond (op0);
5287       if (! add)
5288         return old;
5289       return gen_rtx_AND (0, old, x);
5290
5291     default:
5292       abort ();
5293     }
5294 }
5295
5296 /* Given a condition X, remove references to reg REGNO and return the
5297    new condition.  The removal will be done so that all conditions
5298    involving REGNO are considered to evaluate to false.  This function
5299    is used when the value of REGNO changes.  */
5300
5301 static rtx
5302 elim_reg_cond (x, regno)
5303      rtx x;
5304      unsigned int regno;
5305 {
5306   rtx op0, op1;
5307
5308   if (GET_RTX_CLASS (GET_CODE (x)) == '<')
5309     {
5310       if (REGNO (XEXP (x, 0)) == regno)
5311         return const0_rtx;
5312       return x;
5313     }
5314
5315   switch (GET_CODE (x))
5316     {
5317     case AND:
5318       op0 = elim_reg_cond (XEXP (x, 0), regno);
5319       op1 = elim_reg_cond (XEXP (x, 1), regno);
5320       if (op0 == const0_rtx || op1 == const0_rtx)
5321         return const0_rtx;
5322       if (op0 == const1_rtx)
5323         return op1;
5324       if (op1 == const1_rtx)
5325         return op0;
5326       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
5327         return x;
5328       return gen_rtx_AND (0, op0, op1);
5329
5330     case IOR:
5331       op0 = elim_reg_cond (XEXP (x, 0), regno);
5332       op1 = elim_reg_cond (XEXP (x, 1), regno);
5333       if (op0 == const1_rtx || op1 == const1_rtx)
5334         return const1_rtx;
5335       if (op0 == const0_rtx)
5336         return op1;
5337       if (op1 == const0_rtx)
5338         return op0;
5339       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
5340         return x;
5341       return gen_rtx_IOR (0, op0, op1);
5342
5343     case NOT:
5344       op0 = elim_reg_cond (XEXP (x, 0), regno);
5345       if (op0 == const0_rtx)
5346         return const1_rtx;
5347       if (op0 == const1_rtx)
5348         return const0_rtx;
5349       if (op0 != XEXP (x, 0))
5350         return not_reg_cond (op0);
5351       return x;
5352
5353     default:
5354       abort ();
5355     }
5356 }
5357 #endif /* HAVE_conditional_execution */
5358 \f
5359 #ifdef AUTO_INC_DEC
5360
5361 /* Try to substitute the auto-inc expression INC as the address inside
5362    MEM which occurs in INSN.  Currently, the address of MEM is an expression
5363    involving INCR_REG, and INCR is the next use of INCR_REG; it is an insn
5364    that has a single set whose source is a PLUS of INCR_REG and something
5365    else.  */
5366
5367 static void
5368 attempt_auto_inc (pbi, inc, insn, mem, incr, incr_reg)
5369      struct propagate_block_info *pbi;
5370      rtx inc, insn, mem, incr, incr_reg;
5371 {
5372   int regno = REGNO (incr_reg);
5373   rtx set = single_set (incr);
5374   rtx q = SET_DEST (set);
5375   rtx y = SET_SRC (set);
5376   int opnum = XEXP (y, 0) == incr_reg ? 0 : 1;
5377
5378   /* Make sure this reg appears only once in this insn.  */
5379   if (count_occurrences (PATTERN (insn), incr_reg, 1) != 1)
5380     return;
5381
5382   if (dead_or_set_p (incr, incr_reg)
5383       /* Mustn't autoinc an eliminable register.  */
5384       && (regno >= FIRST_PSEUDO_REGISTER
5385           || ! TEST_HARD_REG_BIT (elim_reg_set, regno)))
5386     {
5387       /* This is the simple case.  Try to make the auto-inc.  If
5388          we can't, we are done.  Otherwise, we will do any
5389          needed updates below.  */
5390       if (! validate_change (insn, &XEXP (mem, 0), inc, 0))
5391         return;
5392     }
5393   else if (GET_CODE (q) == REG
5394            /* PREV_INSN used here to check the semi-open interval
5395               [insn,incr).  */
5396            && ! reg_used_between_p (q,  PREV_INSN (insn), incr)
5397            /* We must also check for sets of q as q may be
5398               a call clobbered hard register and there may
5399               be a call between PREV_INSN (insn) and incr.  */
5400            && ! reg_set_between_p (q,  PREV_INSN (insn), incr))
5401     {
5402       /* We have *p followed sometime later by q = p+size.
5403          Both p and q must be live afterward,
5404          and q is not used between INSN and its assignment.
5405          Change it to q = p, ...*q..., q = q+size.
5406          Then fall into the usual case.  */
5407       rtx insns, temp;
5408
5409       start_sequence ();
5410       emit_move_insn (q, incr_reg);
5411       insns = get_insns ();
5412       end_sequence ();
5413
5414       if (basic_block_for_insn)
5415         for (temp = insns; temp; temp = NEXT_INSN (temp))
5416           set_block_for_insn (temp, pbi->bb);
5417
5418       /* If we can't make the auto-inc, or can't make the
5419          replacement into Y, exit.  There's no point in making
5420          the change below if we can't do the auto-inc and doing
5421          so is not correct in the pre-inc case.  */
5422
5423       XEXP (inc, 0) = q;
5424       validate_change (insn, &XEXP (mem, 0), inc, 1);
5425       validate_change (incr, &XEXP (y, opnum), q, 1);
5426       if (! apply_change_group ())
5427         return;
5428
5429       /* We now know we'll be doing this change, so emit the
5430          new insn(s) and do the updates.  */
5431       emit_insns_before (insns, insn);
5432
5433       if (pbi->bb->head == insn)
5434         pbi->bb->head = insns;
5435
5436       /* INCR will become a NOTE and INSN won't contain a
5437          use of INCR_REG.  If a use of INCR_REG was just placed in
5438          the insn before INSN, make that the next use.
5439          Otherwise, invalidate it.  */
5440       if (GET_CODE (PREV_INSN (insn)) == INSN
5441           && GET_CODE (PATTERN (PREV_INSN (insn))) == SET
5442           && SET_SRC (PATTERN (PREV_INSN (insn))) == incr_reg)
5443         pbi->reg_next_use[regno] = PREV_INSN (insn);
5444       else
5445         pbi->reg_next_use[regno] = 0;
5446
5447       incr_reg = q;
5448       regno = REGNO (q);
5449
5450       /* REGNO is now used in INCR which is below INSN, but
5451          it previously wasn't live here.  If we don't mark
5452          it as live, we'll put a REG_DEAD note for it
5453          on this insn, which is incorrect.  */
5454       SET_REGNO_REG_SET (pbi->reg_live, regno);
5455
5456       /* If there are any calls between INSN and INCR, show
5457          that REGNO now crosses them.  */
5458       for (temp = insn; temp != incr; temp = NEXT_INSN (temp))
5459         if (GET_CODE (temp) == CALL_INSN)
5460           REG_N_CALLS_CROSSED (regno)++;
5461     }
5462   else
5463     return;
5464
5465   /* If we haven't returned, it means we were able to make the
5466      auto-inc, so update the status.  First, record that this insn
5467      has an implicit side effect.  */
5468
5469   REG_NOTES (insn) = alloc_EXPR_LIST (REG_INC, incr_reg, REG_NOTES (insn));
5470
5471   /* Modify the old increment-insn to simply copy
5472      the already-incremented value of our register.  */
5473   if (! validate_change (incr, &SET_SRC (set), incr_reg, 0))
5474     abort ();
5475
5476   /* If that makes it a no-op (copying the register into itself) delete
5477      it so it won't appear to be a "use" and a "set" of this
5478      register.  */
5479   if (REGNO (SET_DEST (set)) == REGNO (incr_reg))
5480     {
5481       /* If the original source was dead, it's dead now.  */
5482       rtx note;
5483
5484       while ((note = find_reg_note (incr, REG_DEAD, NULL_RTX)) != NULL_RTX)
5485         {
5486           remove_note (incr, note);
5487           if (XEXP (note, 0) != incr_reg)
5488             CLEAR_REGNO_REG_SET (pbi->reg_live, REGNO (XEXP (note, 0)));
5489         }
5490
5491       PUT_CODE (incr, NOTE);
5492       NOTE_LINE_NUMBER (incr) = NOTE_INSN_DELETED;
5493       NOTE_SOURCE_FILE (incr) = 0;
5494     }
5495
5496   if (regno >= FIRST_PSEUDO_REGISTER)
5497     {
5498       /* Count an extra reference to the reg.  When a reg is
5499          incremented, spilling it is worse, so we want to make
5500          that less likely.  */
5501       REG_N_REFS (regno) += (optimize_size ? 1 : pbi->bb->loop_depth + 1);
5502
5503       /* Count the increment as a setting of the register,
5504          even though it isn't a SET in rtl.  */
5505       REG_N_SETS (regno)++;
5506     }
5507 }
5508
5509 /* X is a MEM found in INSN.  See if we can convert it into an auto-increment
5510    reference.  */
5511
5512 static void
5513 find_auto_inc (pbi, x, insn)
5514      struct propagate_block_info *pbi;
5515      rtx x;
5516      rtx insn;
5517 {
5518   rtx addr = XEXP (x, 0);
5519   HOST_WIDE_INT offset = 0;
5520   rtx set, y, incr, inc_val;
5521   int regno;
5522   int size = GET_MODE_SIZE (GET_MODE (x));
5523
5524   if (GET_CODE (insn) == JUMP_INSN)
5525     return;
5526
5527   /* Here we detect use of an index register which might be good for
5528      postincrement, postdecrement, preincrement, or predecrement.  */
5529
5530   if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
5531     offset = INTVAL (XEXP (addr, 1)), addr = XEXP (addr, 0);
5532
5533   if (GET_CODE (addr) != REG)
5534     return;
5535
5536   regno = REGNO (addr);
5537
5538   /* Is the next use an increment that might make auto-increment? */
5539   incr = pbi->reg_next_use[regno];
5540   if (incr == 0 || BLOCK_NUM (incr) != BLOCK_NUM (insn))
5541     return;
5542   set = single_set (incr);
5543   if (set == 0 || GET_CODE (set) != SET)
5544     return;
5545   y = SET_SRC (set);
5546
5547   if (GET_CODE (y) != PLUS)
5548     return;
5549
5550   if (REG_P (XEXP (y, 0)) && REGNO (XEXP (y, 0)) == REGNO (addr))
5551     inc_val = XEXP (y, 1);
5552   else if (REG_P (XEXP (y, 1)) && REGNO (XEXP (y, 1)) == REGNO (addr))
5553     inc_val = XEXP (y, 0);
5554   else
5555     return;
5556
5557   if (GET_CODE (inc_val) == CONST_INT)
5558     {
5559       if (HAVE_POST_INCREMENT
5560           && (INTVAL (inc_val) == size && offset == 0))
5561         attempt_auto_inc (pbi, gen_rtx_POST_INC (Pmode, addr), insn, x,
5562                           incr, addr);
5563       else if (HAVE_POST_DECREMENT
5564                && (INTVAL (inc_val) == -size && offset == 0))
5565         attempt_auto_inc (pbi, gen_rtx_POST_DEC (Pmode, addr), insn, x,
5566                           incr, addr);
5567       else if (HAVE_PRE_INCREMENT
5568                && (INTVAL (inc_val) == size && offset == size))
5569         attempt_auto_inc (pbi, gen_rtx_PRE_INC (Pmode, addr), insn, x,
5570                           incr, addr);
5571       else if (HAVE_PRE_DECREMENT
5572                && (INTVAL (inc_val) == -size && offset == -size))
5573         attempt_auto_inc (pbi, gen_rtx_PRE_DEC (Pmode, addr), insn, x,
5574                           incr, addr);
5575       else if (HAVE_POST_MODIFY_DISP && offset == 0)
5576         attempt_auto_inc (pbi, gen_rtx_POST_MODIFY (Pmode, addr,
5577                                                     gen_rtx_PLUS (Pmode,
5578                                                                   addr,
5579                                                                   inc_val)),
5580                           insn, x, incr, addr);
5581     }
5582   else if (GET_CODE (inc_val) == REG
5583            && ! reg_set_between_p (inc_val, PREV_INSN (insn),
5584                                    NEXT_INSN (incr)))
5585
5586     {
5587       if (HAVE_POST_MODIFY_REG && offset == 0)
5588         attempt_auto_inc (pbi, gen_rtx_POST_MODIFY (Pmode, addr,
5589                                                     gen_rtx_PLUS (Pmode,
5590                                                                   addr,
5591                                                                   inc_val)),
5592                           insn, x, incr, addr);
5593     }
5594 }
5595
5596 #endif /* AUTO_INC_DEC */
5597 \f
5598 static void
5599 mark_used_reg (pbi, reg, cond, insn)
5600      struct propagate_block_info *pbi;
5601      rtx reg;
5602      rtx cond ATTRIBUTE_UNUSED;
5603      rtx insn;
5604 {
5605   int regno = REGNO (reg);
5606   int some_was_live = REGNO_REG_SET_P (pbi->reg_live, regno);
5607   int some_was_dead = ! some_was_live;
5608   int some_not_set;
5609   int n;
5610
5611   /* A hard reg in a wide mode may really be multiple registers.
5612      If so, mark all of them just like the first.  */
5613   if (regno < FIRST_PSEUDO_REGISTER)
5614     {
5615       n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5616       while (--n > 0)
5617         {
5618           int needed_regno = REGNO_REG_SET_P (pbi->reg_live, regno + n);
5619           some_was_live |= needed_regno;
5620           some_was_dead |= ! needed_regno;
5621         }
5622     }
5623
5624   if (pbi->flags & (PROP_LOG_LINKS | PROP_AUTOINC))
5625     {
5626       /* Record where each reg is used, so when the reg is set we know
5627          the next insn that uses it.  */
5628       pbi->reg_next_use[regno] = insn;
5629     }
5630
5631   if (pbi->flags & PROP_REG_INFO)
5632     {
5633       if (regno < FIRST_PSEUDO_REGISTER)
5634         {
5635           /* If this is a register we are going to try to eliminate,
5636              don't mark it live here.  If we are successful in
5637              eliminating it, it need not be live unless it is used for
5638              pseudos, in which case it will have been set live when it
5639              was allocated to the pseudos.  If the register will not
5640              be eliminated, reload will set it live at that point.
5641
5642              Otherwise, record that this function uses this register.  */
5643           /* ??? The PPC backend tries to "eliminate" on the pic
5644              register to itself.  This should be fixed.  In the mean
5645              time, hack around it.  */
5646
5647           if (! (TEST_HARD_REG_BIT (elim_reg_set, regno)
5648                  && (regno == FRAME_POINTER_REGNUM
5649                      || regno == ARG_POINTER_REGNUM)))
5650             {
5651               int n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5652               do
5653                 regs_ever_live[regno + --n] = 1;
5654               while (n > 0);
5655             }
5656         }
5657       else
5658         {
5659           /* Keep track of which basic block each reg appears in.  */
5660
5661           register int blocknum = pbi->bb->index;
5662           if (REG_BASIC_BLOCK (regno) == REG_BLOCK_UNKNOWN)
5663             REG_BASIC_BLOCK (regno) = blocknum;
5664           else if (REG_BASIC_BLOCK (regno) != blocknum)
5665             REG_BASIC_BLOCK (regno) = REG_BLOCK_GLOBAL;
5666
5667           /* Count (weighted) number of uses of each reg.  */
5668           REG_N_REFS (regno) += (optimize_size ? 1
5669                                  : pbi->bb->loop_depth + 1);
5670         }
5671     }
5672
5673   /* Find out if any of the register was set this insn.  */
5674   some_not_set = ! REGNO_REG_SET_P (pbi->new_set, regno);
5675   if (regno < FIRST_PSEUDO_REGISTER)
5676     {
5677       n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5678       while (--n > 0)
5679         some_not_set |= ! REGNO_REG_SET_P (pbi->new_set, regno + n);
5680     }
5681
5682   /* Record and count the insns in which a reg dies.  If it is used in
5683      this insn and was dead below the insn then it dies in this insn.
5684      If it was set in this insn, we do not make a REG_DEAD note;
5685      likewise if we already made such a note.  */
5686   if ((pbi->flags & (PROP_DEATH_NOTES | PROP_REG_INFO))
5687       && some_was_dead
5688       && some_not_set)
5689     {
5690       /* Check for the case where the register dying partially
5691          overlaps the register set by this insn.  */
5692       if (regno < FIRST_PSEUDO_REGISTER
5693           && HARD_REGNO_NREGS (regno, GET_MODE (reg)) > 1)
5694         {
5695           n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5696           while (--n >= 0)
5697             some_was_live |= REGNO_REG_SET_P (pbi->new_set, regno + n);
5698         }
5699
5700       /* If none of the words in X is needed, make a REG_DEAD note.
5701          Otherwise, we must make partial REG_DEAD notes.  */
5702       if (! some_was_live)
5703         {
5704           if ((pbi->flags & PROP_DEATH_NOTES)
5705               && ! find_regno_note (insn, REG_DEAD, regno))
5706             REG_NOTES (insn)
5707               = alloc_EXPR_LIST (REG_DEAD, reg, REG_NOTES (insn));
5708
5709           if (pbi->flags & PROP_REG_INFO)
5710             REG_N_DEATHS (regno)++;
5711         }
5712       else
5713         {
5714           /* Don't make a REG_DEAD note for a part of a register
5715              that is set in the insn.  */
5716
5717           n = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1;
5718           for (; n >= regno; n--)
5719             if (! REGNO_REG_SET_P (pbi->reg_live, n)
5720                 && ! dead_or_set_regno_p (insn, n))
5721               REG_NOTES (insn)
5722                 = alloc_EXPR_LIST (REG_DEAD,
5723                                    gen_rtx_REG (reg_raw_mode[n], n),
5724                                    REG_NOTES (insn));
5725         }
5726     }
5727
5728   SET_REGNO_REG_SET (pbi->reg_live, regno);
5729   if (regno < FIRST_PSEUDO_REGISTER)
5730     {
5731       n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
5732       while (--n > 0)
5733         SET_REGNO_REG_SET (pbi->reg_live, regno + n);
5734     }
5735
5736 #ifdef HAVE_conditional_execution
5737   /* If this is a conditional use, record that fact.  If it is later
5738      conditionally set, we'll know to kill the register.  */
5739   if (cond != NULL_RTX)
5740     {
5741       splay_tree_node node;
5742       struct reg_cond_life_info *rcli;
5743       rtx ncond;
5744
5745       if (some_was_live)
5746         {
5747           node = splay_tree_lookup (pbi->reg_cond_dead, regno);
5748           if (node == NULL)
5749             {
5750               /* The register was unconditionally live previously.
5751                  No need to do anything.  */
5752             }
5753           else
5754             {
5755               /* The register was conditionally live previously.
5756                  Subtract the new life cond from the old death cond.  */
5757               rcli = (struct reg_cond_life_info *) node->value;
5758               ncond = rcli->condition;
5759               ncond = and_reg_cond (ncond, not_reg_cond (cond), 1);
5760
5761               /* If the register is now unconditionally live, remove the
5762                  entry in the splay_tree.  */
5763               if (ncond == const0_rtx)
5764                 {
5765                   rcli->condition = NULL_RTX;
5766                   splay_tree_remove (pbi->reg_cond_dead, regno);
5767                 }
5768               else
5769                 {
5770                   rcli->condition = ncond;
5771                   SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
5772                 }
5773             }
5774         }
5775       else
5776         {
5777           /* The register was not previously live at all.  Record
5778              the condition under which it is still dead.  */
5779           rcli = (struct reg_cond_life_info *) xmalloc (sizeof (*rcli));
5780           rcli->condition = not_reg_cond (cond);
5781           splay_tree_insert (pbi->reg_cond_dead, regno,
5782                              (splay_tree_value) rcli);
5783
5784           SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (XEXP (cond, 0)));
5785         }
5786     }
5787   else if (some_was_live)
5788     {
5789       splay_tree_node node;
5790       struct reg_cond_life_info *rcli;
5791
5792       node = splay_tree_lookup (pbi->reg_cond_dead, regno);
5793       if (node != NULL)
5794         {
5795           /* The register was conditionally live previously, but is now
5796              unconditionally so.  Remove it from the conditionally dead
5797              list, so that a conditional set won't cause us to think
5798              it dead.  */
5799           rcli = (struct reg_cond_life_info *) node->value;
5800           rcli->condition = NULL_RTX;
5801           splay_tree_remove (pbi->reg_cond_dead, regno);
5802         }
5803     }
5804
5805 #endif
5806 }
5807
5808 /* Scan expression X and store a 1-bit in NEW_LIVE for each reg it uses.
5809    This is done assuming the registers needed from X are those that
5810    have 1-bits in PBI->REG_LIVE.
5811
5812    INSN is the containing instruction.  If INSN is dead, this function
5813    is not called.  */
5814
5815 static void
5816 mark_used_regs (pbi, x, cond, insn)
5817      struct propagate_block_info *pbi;
5818      rtx x, cond, insn;
5819 {
5820   register RTX_CODE code;
5821   register int regno;
5822   int flags = pbi->flags;
5823
5824  retry:
5825   code = GET_CODE (x);
5826   switch (code)
5827     {
5828     case LABEL_REF:
5829     case SYMBOL_REF:
5830     case CONST_INT:
5831     case CONST:
5832     case CONST_DOUBLE:
5833     case PC:
5834     case ADDR_VEC:
5835     case ADDR_DIFF_VEC:
5836       return;
5837
5838 #ifdef HAVE_cc0
5839     case CC0:
5840       pbi->cc0_live = 1;
5841       return;
5842 #endif
5843
5844     case CLOBBER:
5845       /* If we are clobbering a MEM, mark any registers inside the address
5846          as being used.  */
5847       if (GET_CODE (XEXP (x, 0)) == MEM)
5848         mark_used_regs (pbi, XEXP (XEXP (x, 0), 0), cond, insn);
5849       return;
5850
5851     case MEM:
5852       /* Don't bother watching stores to mems if this is not the
5853          final pass.  We'll not be deleting dead stores this round.  */
5854       if (optimize && (flags & PROP_SCAN_DEAD_CODE))
5855         {
5856           /* Invalidate the data for the last MEM stored, but only if MEM is
5857              something that can be stored into.  */
5858           if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
5859               && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
5860             /* Needn't clear the memory set list.  */
5861             ;
5862           else
5863             {
5864               rtx temp = pbi->mem_set_list;
5865               rtx prev = NULL_RTX;
5866               rtx next;
5867
5868               while (temp)
5869                 {
5870                   next = XEXP (temp, 1);
5871                   if (anti_dependence (XEXP (temp, 0), x))
5872                     {
5873                       /* Splice temp out of the list.  */
5874                       if (prev)
5875                         XEXP (prev, 1) = next;
5876                       else
5877                         pbi->mem_set_list = next;
5878                       free_EXPR_LIST_node (temp);
5879                       pbi->mem_set_list_len--;
5880                     }
5881                   else
5882                     prev = temp;
5883                   temp = next;
5884                 }
5885             }
5886
5887           /* If the memory reference had embedded side effects (autoincrement
5888              address modes.  Then we may need to kill some entries on the
5889              memory set list.  */
5890           if (insn)
5891             invalidate_mems_from_autoinc (pbi, insn);
5892         }
5893
5894 #ifdef AUTO_INC_DEC
5895       if (flags & PROP_AUTOINC)
5896         find_auto_inc (pbi, x, insn);
5897 #endif
5898       break;
5899
5900     case SUBREG:
5901 #ifdef CLASS_CANNOT_CHANGE_MODE
5902       if (GET_CODE (SUBREG_REG (x)) == REG
5903           && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER
5904           && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (x),
5905                                          GET_MODE (SUBREG_REG (x))))
5906         REG_CHANGES_MODE (REGNO (SUBREG_REG (x))) = 1;
5907 #endif
5908
5909       /* While we're here, optimize this case.  */
5910       x = SUBREG_REG (x);
5911       if (GET_CODE (x) != REG)
5912         goto retry;
5913       /* Fall through.  */
5914
5915     case REG:
5916       /* See a register other than being set => mark it as needed.  */
5917       mark_used_reg (pbi, x, cond, insn);
5918       return;
5919
5920     case SET:
5921       {
5922         register rtx testreg = SET_DEST (x);
5923         int mark_dest = 0;
5924
5925         /* If storing into MEM, don't show it as being used.  But do
5926            show the address as being used.  */
5927         if (GET_CODE (testreg) == MEM)
5928           {
5929 #ifdef AUTO_INC_DEC
5930             if (flags & PROP_AUTOINC)
5931               find_auto_inc (pbi, testreg, insn);
5932 #endif
5933             mark_used_regs (pbi, XEXP (testreg, 0), cond, insn);
5934             mark_used_regs (pbi, SET_SRC (x), cond, insn);
5935             return;
5936           }
5937
5938         /* Storing in STRICT_LOW_PART is like storing in a reg
5939            in that this SET might be dead, so ignore it in TESTREG.
5940            but in some other ways it is like using the reg.
5941
5942            Storing in a SUBREG or a bit field is like storing the entire
5943            register in that if the register's value is not used
5944            then this SET is not needed.  */
5945         while (GET_CODE (testreg) == STRICT_LOW_PART
5946                || GET_CODE (testreg) == ZERO_EXTRACT
5947                || GET_CODE (testreg) == SIGN_EXTRACT
5948                || GET_CODE (testreg) == SUBREG)
5949           {
5950 #ifdef CLASS_CANNOT_CHANGE_MODE
5951             if (GET_CODE (testreg) == SUBREG
5952                 && GET_CODE (SUBREG_REG (testreg)) == REG
5953                 && REGNO (SUBREG_REG (testreg)) >= FIRST_PSEUDO_REGISTER
5954                 && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (SUBREG_REG (testreg)),
5955                                                GET_MODE (testreg)))
5956               REG_CHANGES_MODE (REGNO (SUBREG_REG (testreg))) = 1;
5957 #endif
5958
5959             /* Modifying a single register in an alternate mode
5960                does not use any of the old value.  But these other
5961                ways of storing in a register do use the old value.  */
5962             if (GET_CODE (testreg) == SUBREG
5963                 && !(REG_SIZE (SUBREG_REG (testreg)) > REG_SIZE (testreg)))
5964               ;
5965             else
5966               mark_dest = 1;
5967
5968             testreg = XEXP (testreg, 0);
5969           }
5970
5971         /* If this is a store into a register, recursively scan the
5972            value being stored.  */
5973
5974         if ((GET_CODE (testreg) == PARALLEL
5975              && GET_MODE (testreg) == BLKmode)
5976             || (GET_CODE (testreg) == REG
5977                 && (regno = REGNO (testreg),
5978                     ! (regno == FRAME_POINTER_REGNUM
5979                        && (! reload_completed || frame_pointer_needed)))
5980 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
5981                 && ! (regno == HARD_FRAME_POINTER_REGNUM
5982                       && (! reload_completed || frame_pointer_needed))
5983 #endif
5984 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
5985                 && ! (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
5986 #endif
5987                 ))
5988           {
5989             if (mark_dest)
5990               mark_used_regs (pbi, SET_DEST (x), cond, insn);
5991             mark_used_regs (pbi, SET_SRC (x), cond, insn);
5992             return;
5993           }
5994       }
5995       break;
5996
5997     case ASM_OPERANDS:
5998     case UNSPEC_VOLATILE:
5999     case TRAP_IF:
6000     case ASM_INPUT:
6001       {
6002         /* Traditional and volatile asm instructions must be considered to use
6003            and clobber all hard registers, all pseudo-registers and all of
6004            memory.  So must TRAP_IF and UNSPEC_VOLATILE operations.
6005
6006            Consider for instance a volatile asm that changes the fpu rounding
6007            mode.  An insn should not be moved across this even if it only uses
6008            pseudo-regs because it might give an incorrectly rounded result.
6009
6010            ?!? Unfortunately, marking all hard registers as live causes massive
6011            problems for the register allocator and marking all pseudos as live
6012            creates mountains of uninitialized variable warnings.
6013
6014            So for now, just clear the memory set list and mark any regs
6015            we can find in ASM_OPERANDS as used.  */
6016         if (code != ASM_OPERANDS || MEM_VOLATILE_P (x))
6017           {
6018             free_EXPR_LIST_list (&pbi->mem_set_list);
6019             pbi->mem_set_list_len = 0;
6020           }
6021
6022         /* For all ASM_OPERANDS, we must traverse the vector of input operands.
6023            We can not just fall through here since then we would be confused
6024            by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
6025            traditional asms unlike their normal usage.  */
6026         if (code == ASM_OPERANDS)
6027           {
6028             int j;
6029
6030             for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++)
6031               mark_used_regs (pbi, ASM_OPERANDS_INPUT (x, j), cond, insn);
6032           }
6033         break;
6034       }
6035
6036     case COND_EXEC:
6037       if (cond != NULL_RTX)
6038         abort ();
6039
6040       mark_used_regs (pbi, COND_EXEC_TEST (x), NULL_RTX, insn);
6041
6042       cond = COND_EXEC_TEST (x);
6043       x = COND_EXEC_CODE (x);
6044       goto retry;
6045
6046     case PHI:
6047       /* We _do_not_ want to scan operands of phi nodes.  Operands of
6048          a phi function are evaluated only when control reaches this
6049          block along a particular edge.  Therefore, regs that appear
6050          as arguments to phi should not be added to the global live at
6051          start.  */
6052       return;
6053
6054     default:
6055       break;
6056     }
6057
6058   /* Recursively scan the operands of this expression.  */
6059
6060   {
6061     register const char *fmt = GET_RTX_FORMAT (code);
6062     register int i;
6063
6064     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6065       {
6066         if (fmt[i] == 'e')
6067           {
6068             /* Tail recursive case: save a function call level.  */
6069             if (i == 0)
6070               {
6071                 x = XEXP (x, 0);
6072                 goto retry;
6073               }
6074             mark_used_regs (pbi, XEXP (x, i), cond, insn);
6075           }
6076         else if (fmt[i] == 'E')
6077           {
6078             register int j;
6079             for (j = 0; j < XVECLEN (x, i); j++)
6080               mark_used_regs (pbi, XVECEXP (x, i, j), cond, insn);
6081           }
6082       }
6083   }
6084 }
6085 \f
6086 #ifdef AUTO_INC_DEC
6087
6088 static int
6089 try_pre_increment_1 (pbi, insn)
6090      struct propagate_block_info *pbi;
6091      rtx insn;
6092 {
6093   /* Find the next use of this reg.  If in same basic block,
6094      make it do pre-increment or pre-decrement if appropriate.  */
6095   rtx x = single_set (insn);
6096   HOST_WIDE_INT amount = ((GET_CODE (SET_SRC (x)) == PLUS ? 1 : -1)
6097                           * INTVAL (XEXP (SET_SRC (x), 1)));
6098   int regno = REGNO (SET_DEST (x));
6099   rtx y = pbi->reg_next_use[regno];
6100   if (y != 0
6101       && SET_DEST (x) != stack_pointer_rtx
6102       && BLOCK_NUM (y) == BLOCK_NUM (insn)
6103       /* Don't do this if the reg dies, or gets set in y; a standard addressing
6104          mode would be better.  */
6105       && ! dead_or_set_p (y, SET_DEST (x))
6106       && try_pre_increment (y, SET_DEST (x), amount))
6107     {
6108       /* We have found a suitable auto-increment and already changed
6109          insn Y to do it.  So flush this increment instruction.  */
6110       propagate_block_delete_insn (pbi->bb, insn);
6111
6112       /* Count a reference to this reg for the increment insn we are
6113          deleting.  When a reg is incremented, spilling it is worse,
6114          so we want to make that less likely.  */
6115       if (regno >= FIRST_PSEUDO_REGISTER)
6116         {
6117           REG_N_REFS (regno) += (optimize_size ? 1
6118                                  : pbi->bb->loop_depth + 1);
6119           REG_N_SETS (regno)++;
6120         }
6121
6122       /* Flush any remembered memories depending on the value of
6123          the incremented register.  */
6124       invalidate_mems_from_set (pbi, SET_DEST (x));
6125
6126       return 1;
6127     }
6128   return 0;
6129 }
6130
6131 /* Try to change INSN so that it does pre-increment or pre-decrement
6132    addressing on register REG in order to add AMOUNT to REG.
6133    AMOUNT is negative for pre-decrement.
6134    Returns 1 if the change could be made.
6135    This checks all about the validity of the result of modifying INSN.  */
6136
6137 static int
6138 try_pre_increment (insn, reg, amount)
6139      rtx insn, reg;
6140      HOST_WIDE_INT amount;
6141 {
6142   register rtx use;
6143
6144   /* Nonzero if we can try to make a pre-increment or pre-decrement.
6145      For example, addl $4,r1; movl (r1),... can become movl +(r1),...  */
6146   int pre_ok = 0;
6147   /* Nonzero if we can try to make a post-increment or post-decrement.
6148      For example, addl $4,r1; movl -4(r1),... can become movl (r1)+,...
6149      It is possible for both PRE_OK and POST_OK to be nonzero if the machine
6150      supports both pre-inc and post-inc, or both pre-dec and post-dec.  */
6151   int post_ok = 0;
6152
6153   /* Nonzero if the opportunity actually requires post-inc or post-dec.  */
6154   int do_post = 0;
6155
6156   /* From the sign of increment, see which possibilities are conceivable
6157      on this target machine.  */
6158   if (HAVE_PRE_INCREMENT && amount > 0)
6159     pre_ok = 1;
6160   if (HAVE_POST_INCREMENT && amount > 0)
6161     post_ok = 1;
6162
6163   if (HAVE_PRE_DECREMENT && amount < 0)
6164     pre_ok = 1;
6165   if (HAVE_POST_DECREMENT && amount < 0)
6166     post_ok = 1;
6167
6168   if (! (pre_ok || post_ok))
6169     return 0;
6170
6171   /* It is not safe to add a side effect to a jump insn
6172      because if the incremented register is spilled and must be reloaded
6173      there would be no way to store the incremented value back in memory.  */
6174
6175   if (GET_CODE (insn) == JUMP_INSN)
6176     return 0;
6177
6178   use = 0;
6179   if (pre_ok)
6180     use = find_use_as_address (PATTERN (insn), reg, 0);
6181   if (post_ok && (use == 0 || use == (rtx) 1))
6182     {
6183       use = find_use_as_address (PATTERN (insn), reg, -amount);
6184       do_post = 1;
6185     }
6186
6187   if (use == 0 || use == (rtx) 1)
6188     return 0;
6189
6190   if (GET_MODE_SIZE (GET_MODE (use)) != (amount > 0 ? amount : - amount))
6191     return 0;
6192
6193   /* See if this combination of instruction and addressing mode exists.  */
6194   if (! validate_change (insn, &XEXP (use, 0),
6195                          gen_rtx_fmt_e (amount > 0
6196                                         ? (do_post ? POST_INC : PRE_INC)
6197                                         : (do_post ? POST_DEC : PRE_DEC),
6198                                         Pmode, reg), 0))
6199     return 0;
6200
6201   /* Record that this insn now has an implicit side effect on X.  */
6202   REG_NOTES (insn) = alloc_EXPR_LIST (REG_INC, reg, REG_NOTES (insn));
6203   return 1;
6204 }
6205
6206 #endif /* AUTO_INC_DEC */
6207 \f
6208 /* Find the place in the rtx X where REG is used as a memory address.
6209    Return the MEM rtx that so uses it.
6210    If PLUSCONST is nonzero, search instead for a memory address equivalent to
6211    (plus REG (const_int PLUSCONST)).
6212
6213    If such an address does not appear, return 0.
6214    If REG appears more than once, or is used other than in such an address,
6215    return (rtx)1.  */
6216
6217 rtx
6218 find_use_as_address (x, reg, plusconst)
6219      register rtx x;
6220      rtx reg;
6221      HOST_WIDE_INT plusconst;
6222 {
6223   enum rtx_code code = GET_CODE (x);
6224   const char *fmt = GET_RTX_FORMAT (code);
6225   register int i;
6226   register rtx value = 0;
6227   register rtx tem;
6228
6229   if (code == MEM && XEXP (x, 0) == reg && plusconst == 0)
6230     return x;
6231
6232   if (code == MEM && GET_CODE (XEXP (x, 0)) == PLUS
6233       && XEXP (XEXP (x, 0), 0) == reg
6234       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6235       && INTVAL (XEXP (XEXP (x, 0), 1)) == plusconst)
6236     return x;
6237
6238   if (code == SIGN_EXTRACT || code == ZERO_EXTRACT)
6239     {
6240       /* If REG occurs inside a MEM used in a bit-field reference,
6241          that is unacceptable.  */
6242       if (find_use_as_address (XEXP (x, 0), reg, 0) != 0)
6243         return (rtx) (HOST_WIDE_INT) 1;
6244     }
6245
6246   if (x == reg)
6247     return (rtx) (HOST_WIDE_INT) 1;
6248
6249   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6250     {
6251       if (fmt[i] == 'e')
6252         {
6253           tem = find_use_as_address (XEXP (x, i), reg, plusconst);
6254           if (value == 0)
6255             value = tem;
6256           else if (tem != 0)
6257             return (rtx) (HOST_WIDE_INT) 1;
6258         }
6259       else if (fmt[i] == 'E')
6260         {
6261           register int j;
6262           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
6263             {
6264               tem = find_use_as_address (XVECEXP (x, i, j), reg, plusconst);
6265               if (value == 0)
6266                 value = tem;
6267               else if (tem != 0)
6268                 return (rtx) (HOST_WIDE_INT) 1;
6269             }
6270         }
6271     }
6272
6273   return value;
6274 }
6275 \f
6276 /* Write information about registers and basic blocks into FILE.
6277    This is part of making a debugging dump.  */
6278
6279 void
6280 dump_regset (r, outf)
6281      regset r;
6282      FILE *outf;
6283 {
6284   int i;
6285   if (r == NULL)
6286     {
6287       fputs (" (nil)", outf);
6288       return;
6289     }
6290
6291   EXECUTE_IF_SET_IN_REG_SET (r, 0, i,
6292     {
6293       fprintf (outf, " %d", i);
6294       if (i < FIRST_PSEUDO_REGISTER)
6295         fprintf (outf, " [%s]",
6296                  reg_names[i]);
6297     });
6298 }
6299
6300 void
6301 debug_regset (r)
6302      regset r;
6303 {
6304   dump_regset (r, stderr);
6305   putc ('\n', stderr);
6306 }
6307
6308 void
6309 dump_flow_info (file)
6310      FILE *file;
6311 {
6312   register int i;
6313   static const char * const reg_class_names[] = REG_CLASS_NAMES;
6314
6315   fprintf (file, "%d registers.\n", max_regno);
6316   for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
6317     if (REG_N_REFS (i))
6318       {
6319         enum reg_class class, altclass;
6320         fprintf (file, "\nRegister %d used %d times across %d insns",
6321                  i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
6322         if (REG_BASIC_BLOCK (i) >= 0)
6323           fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
6324         if (REG_N_SETS (i))
6325           fprintf (file, "; set %d time%s", REG_N_SETS (i),
6326                    (REG_N_SETS (i) == 1) ? "" : "s");
6327         if (REG_USERVAR_P (regno_reg_rtx[i]))
6328           fprintf (file, "; user var");
6329         if (REG_N_DEATHS (i) != 1)
6330           fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
6331         if (REG_N_CALLS_CROSSED (i) == 1)
6332           fprintf (file, "; crosses 1 call");
6333         else if (REG_N_CALLS_CROSSED (i))
6334           fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
6335         if (PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
6336           fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
6337         class = reg_preferred_class (i);
6338         altclass = reg_alternate_class (i);
6339         if (class != GENERAL_REGS || altclass != ALL_REGS)
6340           {
6341             if (altclass == ALL_REGS || class == ALL_REGS)
6342               fprintf (file, "; pref %s", reg_class_names[(int) class]);
6343             else if (altclass == NO_REGS)
6344               fprintf (file, "; %s or none", reg_class_names[(int) class]);
6345             else
6346               fprintf (file, "; pref %s, else %s",
6347                        reg_class_names[(int) class],
6348                        reg_class_names[(int) altclass]);
6349           }
6350         if (REG_POINTER (regno_reg_rtx[i]))
6351           fprintf (file, "; pointer");
6352         fprintf (file, ".\n");
6353       }
6354
6355   fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
6356   for (i = 0; i < n_basic_blocks; i++)
6357     {
6358       register basic_block bb = BASIC_BLOCK (i);
6359       register edge e;
6360
6361       fprintf (file, "\nBasic block %d: first insn %d, last %d, loop_depth %d, count %d.\n",
6362                i, INSN_UID (bb->head), INSN_UID (bb->end), bb->loop_depth, bb->count);
6363
6364       fprintf (file, "Predecessors: ");
6365       for (e = bb->pred; e; e = e->pred_next)
6366         dump_edge_info (file, e, 0);
6367
6368       fprintf (file, "\nSuccessors: ");
6369       for (e = bb->succ; e; e = e->succ_next)
6370         dump_edge_info (file, e, 1);
6371
6372       fprintf (file, "\nRegisters live at start:");
6373       dump_regset (bb->global_live_at_start, file);
6374
6375       fprintf (file, "\nRegisters live at end:");
6376       dump_regset (bb->global_live_at_end, file);
6377
6378       putc ('\n', file);
6379     }
6380
6381   putc ('\n', file);
6382 }
6383
6384 void
6385 debug_flow_info ()
6386 {
6387   dump_flow_info (stderr);
6388 }
6389
6390 static void
6391 dump_edge_info (file, e, do_succ)
6392      FILE *file;
6393      edge e;
6394      int do_succ;
6395 {
6396   basic_block side = (do_succ ? e->dest : e->src);
6397
6398   if (side == ENTRY_BLOCK_PTR)
6399     fputs (" ENTRY", file);
6400   else if (side == EXIT_BLOCK_PTR)
6401     fputs (" EXIT", file);
6402   else
6403     fprintf (file, " %d", side->index);
6404
6405   if (e->count)
6406     fprintf (file, " count:%d", e->count);
6407
6408   if (e->flags)
6409     {
6410       static const char * const bitnames[] = {
6411         "fallthru", "crit", "ab", "abcall", "eh", "fake"
6412       };
6413       int comma = 0;
6414       int i, flags = e->flags;
6415
6416       fputc (' ', file);
6417       fputc ('(', file);
6418       for (i = 0; flags; i++)
6419         if (flags & (1 << i))
6420           {
6421             flags &= ~(1 << i);
6422
6423             if (comma)
6424               fputc (',', file);
6425             if (i < (int) ARRAY_SIZE (bitnames))
6426               fputs (bitnames[i], file);
6427             else
6428               fprintf (file, "%d", i);
6429             comma = 1;
6430           }
6431       fputc (')', file);
6432     }
6433 }
6434 \f
6435 /* Print out one basic block with live information at start and end.  */
6436
6437 void
6438 dump_bb (bb, outf)
6439      basic_block bb;
6440      FILE *outf;
6441 {
6442   rtx insn;
6443   rtx last;
6444   edge e;
6445
6446   fprintf (outf, ";; Basic block %d, loop depth %d, count %d",
6447            bb->index, bb->loop_depth, bb->count);
6448   if (bb->eh_beg != -1 || bb->eh_end != -1)
6449     fprintf (outf, ", eh regions %d/%d", bb->eh_beg, bb->eh_end);
6450   putc ('\n', outf);
6451
6452   fputs (";; Predecessors: ", outf);
6453   for (e = bb->pred; e; e = e->pred_next)
6454     dump_edge_info (outf, e, 0);
6455   putc ('\n', outf);
6456
6457   fputs (";; Registers live at start:", outf);
6458   dump_regset (bb->global_live_at_start, outf);
6459   putc ('\n', outf);
6460
6461   for (insn = bb->head, last = NEXT_INSN (bb->end);
6462        insn != last;
6463        insn = NEXT_INSN (insn))
6464     print_rtl_single (outf, insn);
6465
6466   fputs (";; Registers live at end:", outf);
6467   dump_regset (bb->global_live_at_end, outf);
6468   putc ('\n', outf);
6469
6470   fputs (";; Successors: ", outf);
6471   for (e = bb->succ; e; e = e->succ_next)
6472     dump_edge_info (outf, e, 1);
6473   putc ('\n', outf);
6474 }
6475
6476 void
6477 debug_bb (bb)
6478      basic_block bb;
6479 {
6480   dump_bb (bb, stderr);
6481 }
6482
6483 void
6484 debug_bb_n (n)
6485      int n;
6486 {
6487   dump_bb (BASIC_BLOCK (n), stderr);
6488 }
6489
6490 /* Like print_rtl, but also print out live information for the start of each
6491    basic block.  */
6492
6493 void
6494 print_rtl_with_bb (outf, rtx_first)
6495      FILE *outf;
6496      rtx rtx_first;
6497 {
6498   register rtx tmp_rtx;
6499
6500   if (rtx_first == 0)
6501     fprintf (outf, "(nil)\n");
6502   else
6503     {
6504       int i;
6505       enum bb_state { NOT_IN_BB, IN_ONE_BB, IN_MULTIPLE_BB };
6506       int max_uid = get_max_uid ();
6507       basic_block *start = (basic_block *)
6508         xcalloc (max_uid, sizeof (basic_block));
6509       basic_block *end = (basic_block *)
6510         xcalloc (max_uid, sizeof (basic_block));
6511       enum bb_state *in_bb_p = (enum bb_state *)
6512         xcalloc (max_uid, sizeof (enum bb_state));
6513
6514       for (i = n_basic_blocks - 1; i >= 0; i--)
6515         {
6516           basic_block bb = BASIC_BLOCK (i);
6517           rtx x;
6518
6519           start[INSN_UID (bb->head)] = bb;
6520           end[INSN_UID (bb->end)] = bb;
6521           for (x = bb->head; x != NULL_RTX; x = NEXT_INSN (x))
6522             {
6523               enum bb_state state = IN_MULTIPLE_BB;
6524               if (in_bb_p[INSN_UID (x)] == NOT_IN_BB)
6525                 state = IN_ONE_BB;
6526               in_bb_p[INSN_UID (x)] = state;
6527
6528               if (x == bb->end)
6529                 break;
6530             }
6531         }
6532
6533       for (tmp_rtx = rtx_first; NULL != tmp_rtx; tmp_rtx = NEXT_INSN (tmp_rtx))
6534         {
6535           int did_output;
6536           basic_block bb;
6537
6538           if ((bb = start[INSN_UID (tmp_rtx)]) != NULL)
6539             {
6540               fprintf (outf, ";; Start of basic block %d, registers live:",
6541                        bb->index);
6542               dump_regset (bb->global_live_at_start, outf);
6543               putc ('\n', outf);
6544             }
6545
6546           if (in_bb_p[INSN_UID (tmp_rtx)] == NOT_IN_BB
6547               && GET_CODE (tmp_rtx) != NOTE
6548               && GET_CODE (tmp_rtx) != BARRIER)
6549             fprintf (outf, ";; Insn is not within a basic block\n");
6550           else if (in_bb_p[INSN_UID (tmp_rtx)] == IN_MULTIPLE_BB)
6551             fprintf (outf, ";; Insn is in multiple basic blocks\n");
6552
6553           did_output = print_rtl_single (outf, tmp_rtx);
6554
6555           if ((bb = end[INSN_UID (tmp_rtx)]) != NULL)
6556             {
6557               fprintf (outf, ";; End of basic block %d, registers live:\n",
6558                        bb->index);
6559               dump_regset (bb->global_live_at_end, outf);
6560               putc ('\n', outf);
6561             }
6562
6563           if (did_output)
6564             putc ('\n', outf);
6565         }
6566
6567       free (start);
6568       free (end);
6569       free (in_bb_p);
6570     }
6571
6572   if (current_function_epilogue_delay_list != 0)
6573     {
6574       fprintf (outf, "\n;; Insns in epilogue delay list:\n\n");
6575       for (tmp_rtx = current_function_epilogue_delay_list; tmp_rtx != 0;
6576            tmp_rtx = XEXP (tmp_rtx, 1))
6577         print_rtl_single (outf, XEXP (tmp_rtx, 0));
6578     }
6579 }
6580
6581 /* Dump the rtl into the current debugging dump file, then abort.  */
6582 static void
6583 print_rtl_and_abort ()
6584 {
6585   if (rtl_dump_file)
6586     {
6587       print_rtl_with_bb (rtl_dump_file, get_insns ());
6588       fclose (rtl_dump_file);
6589     }
6590   abort ();
6591 }
6592
6593 /* Recompute register set/reference counts immediately prior to register
6594    allocation.
6595
6596    This avoids problems with set/reference counts changing to/from values
6597    which have special meanings to the register allocators.
6598
6599    Additionally, the reference counts are the primary component used by the
6600    register allocators to prioritize pseudos for allocation to hard regs.
6601    More accurate reference counts generally lead to better register allocation.
6602
6603    F is the first insn to be scanned.
6604
6605    LOOP_STEP denotes how much loop_depth should be incremented per
6606    loop nesting level in order to increase the ref count more for
6607    references in a loop.
6608
6609    It might be worthwhile to update REG_LIVE_LENGTH, REG_BASIC_BLOCK and
6610    possibly other information which is used by the register allocators.  */
6611
6612 void
6613 recompute_reg_usage (f, loop_step)
6614      rtx f ATTRIBUTE_UNUSED;
6615      int loop_step ATTRIBUTE_UNUSED;
6616 {
6617   allocate_reg_life_data ();
6618   update_life_info (NULL, UPDATE_LIFE_LOCAL, PROP_REG_INFO);
6619 }
6620
6621 /* Optionally removes all the REG_DEAD and REG_UNUSED notes from a set of
6622    blocks.  If BLOCKS is NULL, assume the universal set.  Returns a count
6623    of the number of registers that died.  */
6624
6625 int
6626 count_or_remove_death_notes (blocks, kill)
6627      sbitmap blocks;
6628      int kill;
6629 {
6630   int i, count = 0;
6631
6632   for (i = n_basic_blocks - 1; i >= 0; --i)
6633     {
6634       basic_block bb;
6635       rtx insn;
6636
6637       if (blocks && ! TEST_BIT (blocks, i))
6638         continue;
6639
6640       bb = BASIC_BLOCK (i);
6641
6642       for (insn = bb->head;; insn = NEXT_INSN (insn))
6643         {
6644           if (INSN_P (insn))
6645             {
6646               rtx *pprev = &REG_NOTES (insn);
6647               rtx link = *pprev;
6648
6649               while (link)
6650                 {
6651                   switch (REG_NOTE_KIND (link))
6652                     {
6653                     case REG_DEAD:
6654                       if (GET_CODE (XEXP (link, 0)) == REG)
6655                         {
6656                           rtx reg = XEXP (link, 0);
6657                           int n;
6658
6659                           if (REGNO (reg) >= FIRST_PSEUDO_REGISTER)
6660                             n = 1;
6661                           else
6662                             n = HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg));
6663                           count += n;
6664                         }
6665                       /* Fall through.  */
6666
6667                     case REG_UNUSED:
6668                       if (kill)
6669                         {
6670                           rtx next = XEXP (link, 1);
6671                           free_EXPR_LIST_node (link);
6672                           *pprev = link = next;
6673                           break;
6674                         }
6675                       /* Fall through.  */
6676
6677                     default:
6678                       pprev = &XEXP (link, 1);
6679                       link = *pprev;
6680                       break;
6681                     }
6682                 }
6683             }
6684
6685           if (insn == bb->end)
6686             break;
6687         }
6688     }
6689
6690   return count;
6691 }
6692
6693
6694 /* Update insns block within BB.  */
6695
6696 void
6697 update_bb_for_insn (bb)
6698      basic_block bb;
6699 {
6700   rtx insn;
6701
6702   if (! basic_block_for_insn)
6703     return;
6704
6705   for (insn = bb->head; ; insn = NEXT_INSN (insn))
6706     {
6707       set_block_for_insn (insn, bb);
6708
6709       if (insn == bb->end)
6710         break;
6711     }
6712 }
6713
6714
6715 /* Record INSN's block as BB.  */
6716
6717 void
6718 set_block_for_insn (insn, bb)
6719      rtx insn;
6720      basic_block bb;
6721 {
6722   size_t uid = INSN_UID (insn);
6723   if (uid >= basic_block_for_insn->num_elements)
6724     {
6725       int new_size;
6726
6727       /* Add one-eighth the size so we don't keep calling xrealloc.  */
6728       new_size = uid + (uid + 7) / 8;
6729
6730       VARRAY_GROW (basic_block_for_insn, new_size);
6731     }
6732   VARRAY_BB (basic_block_for_insn, uid) = bb;
6733 }
6734
6735 /* Record INSN's block number as BB.  */
6736 /* ??? This has got to go.  */
6737
6738 void
6739 set_block_num (insn, bb)
6740      rtx insn;
6741      int bb;
6742 {
6743   set_block_for_insn (insn, BASIC_BLOCK (bb));
6744 }
6745 \f
6746 /* Verify the CFG consistency.  This function check some CFG invariants and
6747    aborts when something is wrong.  Hope that this function will help to
6748    convert many optimization passes to preserve CFG consistent.
6749
6750    Currently it does following checks:
6751
6752    - test head/end pointers
6753    - overlapping of basic blocks
6754    - edge list corectness
6755    - headers of basic blocks (the NOTE_INSN_BASIC_BLOCK note)
6756    - tails of basic blocks (ensure that boundary is necesary)
6757    - scans body of the basic block for JUMP_INSN, CODE_LABEL
6758      and NOTE_INSN_BASIC_BLOCK
6759    - check that all insns are in the basic blocks
6760    (except the switch handling code, barriers and notes)
6761    - check that all returns are followed by barriers
6762
6763    In future it can be extended check a lot of other stuff as well
6764    (reachability of basic blocks, life information, etc. etc.).  */
6765
6766 void
6767 verify_flow_info ()
6768 {
6769   const int max_uid = get_max_uid ();
6770   const rtx rtx_first = get_insns ();
6771   rtx last_head = get_last_insn ();
6772   basic_block *bb_info;
6773   rtx x;
6774   int i, last_bb_num_seen, num_bb_notes, err = 0;
6775
6776   bb_info = (basic_block *) xcalloc (max_uid, sizeof (basic_block));
6777
6778   for (i = n_basic_blocks - 1; i >= 0; i--)
6779     {
6780       basic_block bb = BASIC_BLOCK (i);
6781       rtx head = bb->head;
6782       rtx end = bb->end;
6783
6784       /* Verify the end of the basic block is in the INSN chain.  */
6785       for (x = last_head; x != NULL_RTX; x = PREV_INSN (x))
6786         if (x == end)
6787           break;
6788       if (!x)
6789         {
6790           error ("End insn %d for block %d not found in the insn stream.",
6791                  INSN_UID (end), bb->index);
6792           err = 1;
6793         }
6794
6795       /* Work backwards from the end to the head of the basic block
6796          to verify the head is in the RTL chain.  */
6797       for (; x != NULL_RTX; x = PREV_INSN (x))
6798         {
6799           /* While walking over the insn chain, verify insns appear
6800              in only one basic block and initialize the BB_INFO array
6801              used by other passes.  */
6802           if (bb_info[INSN_UID (x)] != NULL)
6803             {
6804               error ("Insn %d is in multiple basic blocks (%d and %d)",
6805                      INSN_UID (x), bb->index, bb_info[INSN_UID (x)]->index);
6806               err = 1;
6807             }
6808           bb_info[INSN_UID (x)] = bb;
6809
6810           if (x == head)
6811             break;
6812         }
6813       if (!x)
6814         {
6815           error ("Head insn %d for block %d not found in the insn stream.",
6816                  INSN_UID (head), bb->index);
6817           err = 1;
6818         }
6819
6820       last_head = x;
6821     }
6822
6823   /* Now check the basic blocks (boundaries etc.) */
6824   for (i = n_basic_blocks - 1; i >= 0; i--)
6825     {
6826       basic_block bb = BASIC_BLOCK (i);
6827       /* Check corectness of edge lists */
6828       edge e;
6829
6830       e = bb->succ;
6831       while (e)
6832         {
6833           if (e->src != bb)
6834             {
6835               fprintf (stderr,
6836                        "verify_flow_info: Basic block %d succ edge is corrupted\n",
6837                        bb->index);
6838               fprintf (stderr, "Predecessor: ");
6839               dump_edge_info (stderr, e, 0);
6840               fprintf (stderr, "\nSuccessor: ");
6841               dump_edge_info (stderr, e, 1);
6842               fflush (stderr);
6843               err = 1;
6844             }
6845           if (e->dest != EXIT_BLOCK_PTR)
6846             {
6847               edge e2 = e->dest->pred;
6848               while (e2 && e2 != e)
6849                 e2 = e2->pred_next;
6850               if (!e2)
6851                 {
6852                   error ("Basic block %i edge lists are corrupted", bb->index);
6853                   err = 1;
6854                 }
6855             }
6856           e = e->succ_next;
6857         }
6858
6859       e = bb->pred;
6860       while (e)
6861         {
6862           if (e->dest != bb)
6863             {
6864               error ("Basic block %d pred edge is corrupted", bb->index);
6865               fputs ("Predecessor: ", stderr);
6866               dump_edge_info (stderr, e, 0);
6867               fputs ("\nSuccessor: ", stderr);
6868               dump_edge_info (stderr, e, 1);
6869               fputc ('\n', stderr);
6870               err = 1;
6871             }
6872           if (e->src != ENTRY_BLOCK_PTR)
6873             {
6874               edge e2 = e->src->succ;
6875               while (e2 && e2 != e)
6876                 e2 = e2->succ_next;
6877               if (!e2)
6878                 {
6879                   error ("Basic block %i edge lists are corrupted", bb->index);
6880                   err = 1;
6881                 }
6882             }
6883           e = e->pred_next;
6884         }
6885
6886       /* OK pointers are correct.  Now check the header of basic
6887          block.  It ought to contain optional CODE_LABEL followed
6888          by NOTE_BASIC_BLOCK.  */
6889       x = bb->head;
6890       if (GET_CODE (x) == CODE_LABEL)
6891         {
6892           if (bb->end == x)
6893             {
6894               error ("NOTE_INSN_BASIC_BLOCK is missing for block %d",
6895                      bb->index);
6896               err = 1;
6897             }
6898           x = NEXT_INSN (x);
6899         }
6900       if (!NOTE_INSN_BASIC_BLOCK_P (x) || NOTE_BASIC_BLOCK (x) != bb)
6901         {
6902           error ("NOTE_INSN_BASIC_BLOCK is missing for block %d\n",
6903                  bb->index);
6904           err = 1;
6905         }
6906
6907       if (bb->end == x)
6908         {
6909           /* Do checks for empty blocks here */
6910         }
6911       else
6912         {
6913           x = NEXT_INSN (x);
6914           while (x)
6915             {
6916               if (NOTE_INSN_BASIC_BLOCK_P (x))
6917                 {
6918                   error ("NOTE_INSN_BASIC_BLOCK %d in the middle of basic block %d",
6919                          INSN_UID (x), bb->index);
6920                   err = 1;
6921                 }
6922
6923               if (x == bb->end)
6924                 break;
6925
6926               if (GET_CODE (x) == JUMP_INSN
6927                   || GET_CODE (x) == CODE_LABEL
6928                   || GET_CODE (x) == BARRIER)
6929                 {
6930                   error ("In basic block %d:", bb->index);
6931                   fatal_insn ("Flow control insn inside a basic block", x);
6932                 }
6933
6934               x = NEXT_INSN (x);
6935             }
6936         }
6937     }
6938
6939   last_bb_num_seen = -1;
6940   num_bb_notes = 0;
6941   x = rtx_first;
6942   while (x)
6943     {
6944       if (NOTE_INSN_BASIC_BLOCK_P (x))
6945         {
6946           basic_block bb = NOTE_BASIC_BLOCK (x);
6947           num_bb_notes++;
6948           if (bb->index != last_bb_num_seen + 1)
6949             fatal ("Basic blocks not numbered consecutively");
6950           last_bb_num_seen = bb->index;
6951         }
6952
6953       if (!bb_info[INSN_UID (x)])
6954         {
6955           switch (GET_CODE (x))
6956             {
6957             case BARRIER:
6958             case NOTE:
6959               break;
6960
6961             case CODE_LABEL:
6962               /* An addr_vec is placed outside any block block.  */
6963               if (NEXT_INSN (x)
6964                   && GET_CODE (NEXT_INSN (x)) == JUMP_INSN
6965                   && (GET_CODE (PATTERN (NEXT_INSN (x))) == ADDR_DIFF_VEC
6966                       || GET_CODE (PATTERN (NEXT_INSN (x))) == ADDR_VEC))
6967                 {
6968                   x = NEXT_INSN (x);
6969                 }
6970
6971               /* But in any case, non-deletable labels can appear anywhere.  */
6972               break;
6973
6974             default:
6975               fatal_insn ("Insn outside basic block", x);
6976             }
6977         }
6978
6979       if (INSN_P (x)
6980           && GET_CODE (x) == JUMP_INSN
6981           && returnjump_p (x) && ! condjump_p (x)
6982           && ! (NEXT_INSN (x) && GET_CODE (NEXT_INSN (x)) == BARRIER))
6983             fatal_insn ("Return not followed by barrier", x);
6984
6985       x = NEXT_INSN (x);
6986     }
6987
6988   if (num_bb_notes != n_basic_blocks)
6989     fatal ("number of bb notes in insn chain (%d) != n_basic_blocks (%d)",
6990            num_bb_notes, n_basic_blocks);
6991
6992   if (err)
6993     abort ();
6994
6995   /* Clean up.  */
6996   free (bb_info);
6997 }
6998 \f
6999 /* Functions to access an edge list with a vector representation.
7000    Enough data is kept such that given an index number, the
7001    pred and succ that edge represents can be determined, or
7002    given a pred and a succ, its index number can be returned.
7003    This allows algorithms which consume a lot of memory to
7004    represent the normally full matrix of edge (pred,succ) with a
7005    single indexed vector,  edge (EDGE_INDEX (pred, succ)), with no
7006    wasted space in the client code due to sparse flow graphs.  */
7007
7008 /* This functions initializes the edge list. Basically the entire
7009    flowgraph is processed, and all edges are assigned a number,
7010    and the data structure is filled in.  */
7011
7012 struct edge_list *
7013 create_edge_list ()
7014 {
7015   struct edge_list *elist;
7016   edge e;
7017   int num_edges;
7018   int x;
7019   int block_count;
7020
7021   block_count = n_basic_blocks + 2;   /* Include the entry and exit blocks.  */
7022
7023   num_edges = 0;
7024
7025   /* Determine the number of edges in the flow graph by counting successor
7026      edges on each basic block.  */
7027   for (x = 0; x < n_basic_blocks; x++)
7028     {
7029       basic_block bb = BASIC_BLOCK (x);
7030
7031       for (e = bb->succ; e; e = e->succ_next)
7032         num_edges++;
7033     }
7034   /* Don't forget successors of the entry block.  */
7035   for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
7036     num_edges++;
7037
7038   elist = (struct edge_list *) xmalloc (sizeof (struct edge_list));
7039   elist->num_blocks = block_count;
7040   elist->num_edges = num_edges;
7041   elist->index_to_edge = (edge *) xmalloc (sizeof (edge) * num_edges);
7042
7043   num_edges = 0;
7044
7045   /* Follow successors of the entry block, and register these edges.  */
7046   for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
7047     {
7048       elist->index_to_edge[num_edges] = e;
7049       num_edges++;
7050     }
7051
7052   for (x = 0; x < n_basic_blocks; x++)
7053     {
7054       basic_block bb = BASIC_BLOCK (x);
7055
7056       /* Follow all successors of blocks, and register these edges.  */
7057       for (e = bb->succ; e; e = e->succ_next)
7058         {
7059           elist->index_to_edge[num_edges] = e;
7060           num_edges++;
7061         }
7062     }
7063   return elist;
7064 }
7065
7066 /* This function free's memory associated with an edge list.  */
7067
7068 void
7069 free_edge_list (elist)
7070      struct edge_list *elist;
7071 {
7072   if (elist)
7073     {
7074       free (elist->index_to_edge);
7075       free (elist);
7076     }
7077 }
7078
7079 /* This function provides debug output showing an edge list.  */
7080
7081 void
7082 print_edge_list (f, elist)
7083      FILE *f;
7084      struct edge_list *elist;
7085 {
7086   int x;
7087   fprintf (f, "Compressed edge list, %d BBs + entry & exit, and %d edges\n",
7088            elist->num_blocks - 2, elist->num_edges);
7089
7090   for (x = 0; x < elist->num_edges; x++)
7091     {
7092       fprintf (f, " %-4d - edge(", x);
7093       if (INDEX_EDGE_PRED_BB (elist, x) == ENTRY_BLOCK_PTR)
7094         fprintf (f, "entry,");
7095       else
7096         fprintf (f, "%d,", INDEX_EDGE_PRED_BB (elist, x)->index);
7097
7098       if (INDEX_EDGE_SUCC_BB (elist, x) == EXIT_BLOCK_PTR)
7099         fprintf (f, "exit)\n");
7100       else
7101         fprintf (f, "%d)\n", INDEX_EDGE_SUCC_BB (elist, x)->index);
7102     }
7103 }
7104
7105 /* This function provides an internal consistency check of an edge list,
7106    verifying that all edges are present, and that there are no
7107    extra edges.  */
7108
7109 void
7110 verify_edge_list (f, elist)
7111      FILE *f;
7112      struct edge_list *elist;
7113 {
7114   int x, pred, succ, index;
7115   edge e;
7116
7117   for (x = 0; x < n_basic_blocks; x++)
7118     {
7119       basic_block bb = BASIC_BLOCK (x);
7120
7121       for (e = bb->succ; e; e = e->succ_next)
7122         {
7123           pred = e->src->index;
7124           succ = e->dest->index;
7125           index = EDGE_INDEX (elist, e->src, e->dest);
7126           if (index == EDGE_INDEX_NO_EDGE)
7127             {
7128               fprintf (f, "*p* No index for edge from %d to %d\n", pred, succ);
7129               continue;
7130             }
7131           if (INDEX_EDGE_PRED_BB (elist, index)->index != pred)
7132             fprintf (f, "*p* Pred for index %d should be %d not %d\n",
7133                      index, pred, INDEX_EDGE_PRED_BB (elist, index)->index);
7134           if (INDEX_EDGE_SUCC_BB (elist, index)->index != succ)
7135             fprintf (f, "*p* Succ for index %d should be %d not %d\n",
7136                      index, succ, INDEX_EDGE_SUCC_BB (elist, index)->index);
7137         }
7138     }
7139   for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
7140     {
7141       pred = e->src->index;
7142       succ = e->dest->index;
7143       index = EDGE_INDEX (elist, e->src, e->dest);
7144       if (index == EDGE_INDEX_NO_EDGE)
7145         {
7146           fprintf (f, "*p* No index for edge from %d to %d\n", pred, succ);
7147           continue;
7148         }
7149       if (INDEX_EDGE_PRED_BB (elist, index)->index != pred)
7150         fprintf (f, "*p* Pred for index %d should be %d not %d\n",
7151                  index, pred, INDEX_EDGE_PRED_BB (elist, index)->index);
7152       if (INDEX_EDGE_SUCC_BB (elist, index)->index != succ)
7153         fprintf (f, "*p* Succ for index %d should be %d not %d\n",
7154                  index, succ, INDEX_EDGE_SUCC_BB (elist, index)->index);
7155     }
7156   /* We've verified that all the edges are in the list, no lets make sure
7157      there are no spurious edges in the list.  */
7158
7159   for (pred = 0; pred < n_basic_blocks; pred++)
7160     for (succ = 0; succ < n_basic_blocks; succ++)
7161       {
7162         basic_block p = BASIC_BLOCK (pred);
7163         basic_block s = BASIC_BLOCK (succ);
7164
7165         int found_edge = 0;
7166
7167         for (e = p->succ; e; e = e->succ_next)
7168           if (e->dest == s)
7169             {
7170               found_edge = 1;
7171               break;
7172             }
7173         for (e = s->pred; e; e = e->pred_next)
7174           if (e->src == p)
7175             {
7176               found_edge = 1;
7177               break;
7178             }
7179         if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
7180             == EDGE_INDEX_NO_EDGE && found_edge != 0)
7181           fprintf (f, "*** Edge (%d, %d) appears to not have an index\n",
7182                    pred, succ);
7183         if (EDGE_INDEX (elist, BASIC_BLOCK (pred), BASIC_BLOCK (succ))
7184             != EDGE_INDEX_NO_EDGE && found_edge == 0)
7185           fprintf (f, "*** Edge (%d, %d) has index %d, but there is no edge\n",
7186                    pred, succ, EDGE_INDEX (elist, BASIC_BLOCK (pred),
7187                                            BASIC_BLOCK (succ)));
7188       }
7189   for (succ = 0; succ < n_basic_blocks; succ++)
7190     {
7191       basic_block p = ENTRY_BLOCK_PTR;
7192       basic_block s = BASIC_BLOCK (succ);
7193
7194       int found_edge = 0;
7195
7196       for (e = p->succ; e; e = e->succ_next)
7197         if (e->dest == s)
7198           {
7199             found_edge = 1;
7200             break;
7201           }
7202       for (e = s->pred; e; e = e->pred_next)
7203         if (e->src == p)
7204           {
7205             found_edge = 1;
7206             break;
7207           }
7208       if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
7209           == EDGE_INDEX_NO_EDGE && found_edge != 0)
7210         fprintf (f, "*** Edge (entry, %d) appears to not have an index\n",
7211                  succ);
7212       if (EDGE_INDEX (elist, ENTRY_BLOCK_PTR, BASIC_BLOCK (succ))
7213           != EDGE_INDEX_NO_EDGE && found_edge == 0)
7214         fprintf (f, "*** Edge (entry, %d) has index %d, but no edge exists\n",
7215                  succ, EDGE_INDEX (elist, ENTRY_BLOCK_PTR,
7216                                    BASIC_BLOCK (succ)));
7217     }
7218   for (pred = 0; pred < n_basic_blocks; pred++)
7219     {
7220       basic_block p = BASIC_BLOCK (pred);
7221       basic_block s = EXIT_BLOCK_PTR;
7222
7223       int found_edge = 0;
7224
7225       for (e = p->succ; e; e = e->succ_next)
7226         if (e->dest == s)
7227           {
7228             found_edge = 1;
7229             break;
7230           }
7231       for (e = s->pred; e; e = e->pred_next)
7232         if (e->src == p)
7233           {
7234             found_edge = 1;
7235             break;
7236           }
7237       if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
7238           == EDGE_INDEX_NO_EDGE && found_edge != 0)
7239         fprintf (f, "*** Edge (%d, exit) appears to not have an index\n",
7240                  pred);
7241       if (EDGE_INDEX (elist, BASIC_BLOCK (pred), EXIT_BLOCK_PTR)
7242           != EDGE_INDEX_NO_EDGE && found_edge == 0)
7243         fprintf (f, "*** Edge (%d, exit) has index %d, but no edge exists\n",
7244                  pred, EDGE_INDEX (elist, BASIC_BLOCK (pred),
7245                                    EXIT_BLOCK_PTR));
7246     }
7247 }
7248
7249 /* This routine will determine what, if any, edge there is between
7250    a specified predecessor and successor.  */
7251
7252 int
7253 find_edge_index (edge_list, pred, succ)
7254      struct edge_list *edge_list;
7255      basic_block pred, succ;
7256 {
7257   int x;
7258   for (x = 0; x < NUM_EDGES (edge_list); x++)
7259     {
7260       if (INDEX_EDGE_PRED_BB (edge_list, x) == pred
7261           && INDEX_EDGE_SUCC_BB (edge_list, x) == succ)
7262         return x;
7263     }
7264   return (EDGE_INDEX_NO_EDGE);
7265 }
7266
7267 /* This function will remove an edge from the flow graph.  */
7268
7269 void
7270 remove_edge (e)
7271      edge e;
7272 {
7273   edge last_pred = NULL;
7274   edge last_succ = NULL;
7275   edge tmp;
7276   basic_block src, dest;
7277   src = e->src;
7278   dest = e->dest;
7279   for (tmp = src->succ; tmp && tmp != e; tmp = tmp->succ_next)
7280     last_succ = tmp;
7281
7282   if (!tmp)
7283     abort ();
7284   if (last_succ)
7285     last_succ->succ_next = e->succ_next;
7286   else
7287     src->succ = e->succ_next;
7288
7289   for (tmp = dest->pred; tmp && tmp != e; tmp = tmp->pred_next)
7290     last_pred = tmp;
7291
7292   if (!tmp)
7293     abort ();
7294   if (last_pred)
7295     last_pred->pred_next = e->pred_next;
7296   else
7297     dest->pred = e->pred_next;
7298
7299   n_edges--;
7300   free (e);
7301 }
7302
7303 /* This routine will remove any fake successor edges for a basic block.
7304    When the edge is removed, it is also removed from whatever predecessor
7305    list it is in.  */
7306
7307 static void
7308 remove_fake_successors (bb)
7309      basic_block bb;
7310 {
7311   edge e;
7312   for (e = bb->succ; e;)
7313     {
7314       edge tmp = e;
7315       e = e->succ_next;
7316       if ((tmp->flags & EDGE_FAKE) == EDGE_FAKE)
7317         remove_edge (tmp);
7318     }
7319 }
7320
7321 /* This routine will remove all fake edges from the flow graph.  If
7322    we remove all fake successors, it will automatically remove all
7323    fake predecessors.  */
7324
7325 void
7326 remove_fake_edges ()
7327 {
7328   int x;
7329
7330   for (x = 0; x < n_basic_blocks; x++)
7331     remove_fake_successors (BASIC_BLOCK (x));
7332
7333   /* We've handled all successors except the entry block's.  */
7334   remove_fake_successors (ENTRY_BLOCK_PTR);
7335 }
7336
7337 /* This function will add a fake edge between any block which has no
7338    successors, and the exit block. Some data flow equations require these
7339    edges to exist.  */
7340
7341 void
7342 add_noreturn_fake_exit_edges ()
7343 {
7344   int x;
7345
7346   for (x = 0; x < n_basic_blocks; x++)
7347     if (BASIC_BLOCK (x)->succ == NULL)
7348       make_edge (NULL, BASIC_BLOCK (x), EXIT_BLOCK_PTR, EDGE_FAKE);
7349 }
7350
7351 /* This function adds a fake edge between any infinite loops to the
7352    exit block.  Some optimizations require a path from each node to
7353    the exit node.
7354
7355    See also Morgan, Figure 3.10, pp. 82-83.
7356
7357    The current implementation is ugly, not attempting to minimize the
7358    number of inserted fake edges.  To reduce the number of fake edges
7359    to insert, add fake edges from _innermost_ loops containing only
7360    nodes not reachable from the exit block.  */
7361
7362 void
7363 connect_infinite_loops_to_exit ()
7364 {
7365   basic_block unvisited_block;
7366
7367   /* Perform depth-first search in the reverse graph to find nodes
7368      reachable from the exit block.  */
7369   struct depth_first_search_dsS dfs_ds;
7370
7371   flow_dfs_compute_reverse_init (&dfs_ds);
7372   flow_dfs_compute_reverse_add_bb (&dfs_ds, EXIT_BLOCK_PTR);
7373
7374   /* Repeatedly add fake edges, updating the unreachable nodes.  */
7375   while (1)
7376     {
7377       unvisited_block = flow_dfs_compute_reverse_execute (&dfs_ds);
7378       if (!unvisited_block)
7379         break;
7380       make_edge (NULL, unvisited_block, EXIT_BLOCK_PTR, EDGE_FAKE);
7381       flow_dfs_compute_reverse_add_bb (&dfs_ds, unvisited_block);
7382     }
7383
7384   flow_dfs_compute_reverse_finish (&dfs_ds);
7385
7386   return;
7387 }
7388
7389 /* Redirect an edge's successor from one block to another.  */
7390
7391 void
7392 redirect_edge_succ (e, new_succ)
7393      edge e;
7394      basic_block new_succ;
7395 {
7396   edge *pe;
7397
7398   /* Disconnect the edge from the old successor block.  */
7399   for (pe = &e->dest->pred; *pe != e; pe = &(*pe)->pred_next)
7400     continue;
7401   *pe = (*pe)->pred_next;
7402
7403   /* Reconnect the edge to the new successor block.  */
7404   e->pred_next = new_succ->pred;
7405   new_succ->pred = e;
7406   e->dest = new_succ;
7407 }
7408
7409 /* Redirect an edge's predecessor from one block to another.  */
7410
7411 void
7412 redirect_edge_pred (e, new_pred)
7413      edge e;
7414      basic_block new_pred;
7415 {
7416   edge *pe;
7417
7418   /* Disconnect the edge from the old predecessor block.  */
7419   for (pe = &e->src->succ; *pe != e; pe = &(*pe)->succ_next)
7420     continue;
7421   *pe = (*pe)->succ_next;
7422
7423   /* Reconnect the edge to the new predecessor block.  */
7424   e->succ_next = new_pred->succ;
7425   new_pred->succ = e;
7426   e->src = new_pred;
7427 }
7428 \f
7429 /* Dump the list of basic blocks in the bitmap NODES.  */
7430
7431 static void
7432 flow_nodes_print (str, nodes, file)
7433      const char *str;
7434      const sbitmap nodes;
7435      FILE *file;
7436 {
7437   int node;
7438
7439   if (! nodes)
7440     return;
7441
7442   fprintf (file, "%s { ", str);
7443   EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {fprintf (file, "%d ", node);});
7444   fputs ("}\n", file);
7445 }
7446
7447
7448 /* Dump the list of edges in the array EDGE_LIST.  */
7449
7450 static void
7451 flow_edge_list_print (str, edge_list, num_edges, file)
7452      const char *str;
7453      const edge *edge_list;
7454      int num_edges;
7455      FILE *file;
7456 {
7457   int i;
7458
7459   if (! edge_list)
7460     return;
7461
7462   fprintf (file, "%s { ", str);
7463   for (i = 0; i < num_edges; i++)
7464     fprintf (file, "%d->%d ", edge_list[i]->src->index,
7465              edge_list[i]->dest->index);
7466   fputs ("}\n", file);
7467 }
7468
7469
7470 /* Dump loop related CFG information.  */
7471
7472 static void
7473 flow_loops_cfg_dump (loops, file)
7474      const struct loops *loops;
7475      FILE *file;
7476 {
7477   int i;
7478
7479   if (! loops->num || ! file || ! loops->cfg.dom)
7480     return;
7481
7482   for (i = 0; i < n_basic_blocks; i++)
7483     {
7484       edge succ;
7485
7486       fprintf (file, ";; %d succs { ", i);
7487       for (succ = BASIC_BLOCK (i)->succ; succ; succ = succ->succ_next)
7488         fprintf (file, "%d ", succ->dest->index);
7489       flow_nodes_print ("} dom", loops->cfg.dom[i], file);
7490     }
7491
7492   /* Dump the DFS node order.  */
7493   if (loops->cfg.dfs_order)
7494     {
7495       fputs (";; DFS order: ", file);
7496       for (i = 0; i < n_basic_blocks; i++)
7497         fprintf (file, "%d ", loops->cfg.dfs_order[i]);
7498       fputs ("\n", file);
7499     }
7500   /* Dump the reverse completion node order.  */
7501   if (loops->cfg.rc_order)
7502     {
7503       fputs (";; RC order: ", file);
7504       for (i = 0; i < n_basic_blocks; i++)
7505         fprintf (file, "%d ", loops->cfg.rc_order[i]);
7506       fputs ("\n", file);
7507     }
7508 }
7509
7510 /* Return non-zero if the nodes of LOOP are a subset of OUTER.  */
7511
7512 static int
7513 flow_loop_nested_p (outer, loop)
7514      struct loop *outer;
7515      struct loop *loop;
7516 {
7517   return sbitmap_a_subset_b_p (loop->nodes, outer->nodes);
7518 }
7519
7520
7521 /* Dump the loop information specified by LOOP to the stream FILE
7522    using auxiliary dump callback function LOOP_DUMP_AUX if non null.  */
7523 void
7524 flow_loop_dump (loop, file, loop_dump_aux, verbose)
7525      const struct loop *loop;
7526      FILE *file;
7527      void (*loop_dump_aux) PARAMS((const struct loop *, FILE *, int));
7528      int verbose;
7529 {
7530   if (! loop || ! loop->header)
7531     return;
7532
7533   fprintf (file, ";;\n;; Loop %d (%d to %d):%s%s\n",
7534            loop->num, INSN_UID (loop->first->head),
7535            INSN_UID (loop->last->end),
7536            loop->shared ? " shared" : "",
7537            loop->invalid ? " invalid" : "");
7538   fprintf (file, ";;  header %d, latch %d, pre-header %d, first %d, last %d\n",
7539            loop->header->index, loop->latch->index,
7540            loop->pre_header ? loop->pre_header->index : -1,
7541            loop->first->index, loop->last->index);
7542   fprintf (file, ";;  depth %d, level %d, outer %ld\n",
7543            loop->depth, loop->level,
7544            (long) (loop->outer ? loop->outer->num : -1));
7545
7546   if (loop->pre_header_edges)
7547     flow_edge_list_print (";;  pre-header edges", loop->pre_header_edges,
7548                           loop->num_pre_header_edges, file);
7549   flow_edge_list_print (";;  entry edges", loop->entry_edges,
7550                         loop->num_entries, file);
7551   fprintf (file, ";;  %d", loop->num_nodes);
7552   flow_nodes_print (" nodes", loop->nodes, file);
7553   flow_edge_list_print (";;  exit edges", loop->exit_edges,
7554                         loop->num_exits, file);
7555   if (loop->exits_doms)
7556     flow_nodes_print (";;  exit doms", loop->exits_doms, file);
7557   if (loop_dump_aux)
7558     loop_dump_aux (loop, file, verbose);
7559 }
7560
7561
7562 /* Dump the loop information specified by LOOPS to the stream FILE,
7563    using auxiliary dump callback function LOOP_DUMP_AUX if non null.  */
7564 void
7565 flow_loops_dump (loops, file, loop_dump_aux, verbose)
7566      const struct loops *loops;
7567      FILE *file;
7568      void (*loop_dump_aux) PARAMS((const struct loop *, FILE *, int));
7569      int verbose;
7570 {
7571   int i;
7572   int num_loops;
7573
7574   num_loops = loops->num;
7575   if (! num_loops || ! file)
7576     return;
7577
7578   fprintf (file, ";; %d loops found, %d levels\n",
7579            num_loops, loops->levels);
7580
7581   for (i = 0; i < num_loops; i++)
7582     {
7583       struct loop *loop = &loops->array[i];
7584
7585       flow_loop_dump (loop, file, loop_dump_aux, verbose);
7586
7587       if (loop->shared)
7588         {
7589           int j;
7590
7591           for (j = 0; j < i; j++)
7592             {
7593               struct loop *oloop = &loops->array[j];
7594
7595               if (loop->header == oloop->header)
7596                 {
7597                   int disjoint;
7598                   int smaller;
7599
7600                   smaller = loop->num_nodes < oloop->num_nodes;
7601
7602                   /* If the union of LOOP and OLOOP is different than
7603                      the larger of LOOP and OLOOP then LOOP and OLOOP
7604                      must be disjoint.  */
7605                   disjoint = ! flow_loop_nested_p (smaller ? loop : oloop,
7606                                                    smaller ? oloop : loop);
7607                   fprintf (file,
7608                            ";; loop header %d shared by loops %d, %d %s\n",
7609                            loop->header->index, i, j,
7610                            disjoint ? "disjoint" : "nested");
7611                 }
7612             }
7613         }
7614     }
7615
7616   if (verbose)
7617     flow_loops_cfg_dump (loops, file);
7618 }
7619
7620
7621 /* Free all the memory allocated for LOOPS.  */
7622
7623 void
7624 flow_loops_free (loops)
7625      struct loops *loops;
7626 {
7627   if (loops->array)
7628     {
7629       int i;
7630
7631       if (! loops->num)
7632         abort ();
7633
7634       /* Free the loop descriptors.  */
7635       for (i = 0; i < loops->num; i++)
7636         {
7637           struct loop *loop = &loops->array[i];
7638
7639           if (loop->pre_header_edges)
7640             free (loop->pre_header_edges);
7641           if (loop->nodes)
7642             sbitmap_free (loop->nodes);
7643           if (loop->entry_edges)
7644             free (loop->entry_edges);
7645           if (loop->exit_edges)
7646             free (loop->exit_edges);
7647           if (loop->exits_doms)
7648             sbitmap_free (loop->exits_doms);
7649         }
7650       free (loops->array);
7651       loops->array = NULL;
7652
7653       if (loops->cfg.dom)
7654         sbitmap_vector_free (loops->cfg.dom);
7655       if (loops->cfg.dfs_order)
7656         free (loops->cfg.dfs_order);
7657
7658       if (loops->shared_headers)
7659         sbitmap_free (loops->shared_headers);
7660     }
7661 }
7662
7663
7664 /* Find the entry edges into the loop with header HEADER and nodes
7665    NODES and store in ENTRY_EDGES array.  Return the number of entry
7666    edges from the loop.  */
7667
7668 static int
7669 flow_loop_entry_edges_find (header, nodes, entry_edges)
7670      basic_block header;
7671      const sbitmap nodes;
7672      edge **entry_edges;
7673 {
7674   edge e;
7675   int num_entries;
7676
7677   *entry_edges = NULL;
7678
7679   num_entries = 0;
7680   for (e = header->pred; e; e = e->pred_next)
7681     {
7682       basic_block src = e->src;
7683
7684       if (src == ENTRY_BLOCK_PTR || ! TEST_BIT (nodes, src->index))
7685         num_entries++;
7686     }
7687
7688   if (! num_entries)
7689     abort ();
7690
7691   *entry_edges = (edge *) xmalloc (num_entries * sizeof (edge *));
7692
7693   num_entries = 0;
7694   for (e = header->pred; e; e = e->pred_next)
7695     {
7696       basic_block src = e->src;
7697
7698       if (src == ENTRY_BLOCK_PTR || ! TEST_BIT (nodes, src->index))
7699         (*entry_edges)[num_entries++] = e;
7700     }
7701
7702   return num_entries;
7703 }
7704
7705
7706 /* Find the exit edges from the loop using the bitmap of loop nodes
7707    NODES and store in EXIT_EDGES array.  Return the number of
7708    exit edges from the loop.  */
7709
7710 static int
7711 flow_loop_exit_edges_find (nodes, exit_edges)
7712      const sbitmap nodes;
7713      edge **exit_edges;
7714 {
7715   edge e;
7716   int node;
7717   int num_exits;
7718
7719   *exit_edges = NULL;
7720
7721   /* Check all nodes within the loop to see if there are any
7722      successors not in the loop.  Note that a node may have multiple
7723      exiting edges ?????  A node can have one jumping edge and one fallthru
7724      edge so only one of these can exit the loop.  */
7725   num_exits = 0;
7726   EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {
7727     for (e = BASIC_BLOCK (node)->succ; e; e = e->succ_next)
7728       {
7729         basic_block dest = e->dest;
7730
7731         if (dest == EXIT_BLOCK_PTR || ! TEST_BIT (nodes, dest->index))
7732             num_exits++;
7733       }
7734   });
7735
7736   if (! num_exits)
7737     return 0;
7738
7739   *exit_edges = (edge *) xmalloc (num_exits * sizeof (edge *));
7740
7741   /* Store all exiting edges into an array.  */
7742   num_exits = 0;
7743   EXECUTE_IF_SET_IN_SBITMAP (nodes, 0, node, {
7744     for (e = BASIC_BLOCK (node)->succ; e; e = e->succ_next)
7745       {
7746         basic_block dest = e->dest;
7747
7748         if (dest == EXIT_BLOCK_PTR || ! TEST_BIT (nodes, dest->index))
7749           (*exit_edges)[num_exits++] = e;
7750       }
7751   });
7752
7753   return num_exits;
7754 }
7755
7756
7757 /* Find the nodes contained within the loop with header HEADER and
7758    latch LATCH and store in NODES.  Return the number of nodes within
7759    the loop.  */
7760
7761 static int
7762 flow_loop_nodes_find (header, latch, nodes)
7763      basic_block header;
7764      basic_block latch;
7765      sbitmap nodes;
7766 {
7767   basic_block *stack;
7768   int sp;
7769   int num_nodes = 0;
7770
7771   stack = (basic_block *) xmalloc (n_basic_blocks * sizeof (basic_block));
7772   sp = 0;
7773
7774   /* Start with only the loop header in the set of loop nodes.  */
7775   sbitmap_zero (nodes);
7776   SET_BIT (nodes, header->index);
7777   num_nodes++;
7778   header->loop_depth++;
7779
7780   /* Push the loop latch on to the stack.  */
7781   if (! TEST_BIT (nodes, latch->index))
7782     {
7783       SET_BIT (nodes, latch->index);
7784       latch->loop_depth++;
7785       num_nodes++;
7786       stack[sp++] = latch;
7787     }
7788
7789   while (sp)
7790     {
7791       basic_block node;
7792       edge e;
7793
7794       node = stack[--sp];
7795       for (e = node->pred; e; e = e->pred_next)
7796         {
7797           basic_block ancestor = e->src;
7798
7799           /* If each ancestor not marked as part of loop, add to set of
7800              loop nodes and push on to stack.  */
7801           if (ancestor != ENTRY_BLOCK_PTR
7802               && ! TEST_BIT (nodes, ancestor->index))
7803             {
7804               SET_BIT (nodes, ancestor->index);
7805               ancestor->loop_depth++;
7806               num_nodes++;
7807               stack[sp++] = ancestor;
7808             }
7809         }
7810     }
7811   free (stack);
7812   return num_nodes;
7813 }
7814
7815 /* Compute the depth first search order and store in the array
7816   DFS_ORDER if non-zero, marking the nodes visited in VISITED.  If
7817   RC_ORDER is non-zero, return the reverse completion number for each
7818   node.  Returns the number of nodes visited.  A depth first search
7819   tries to get as far away from the starting point as quickly as
7820   possible.  */
7821
7822 static int
7823 flow_depth_first_order_compute (dfs_order, rc_order)
7824      int *dfs_order;
7825      int *rc_order;
7826 {
7827   edge *stack;
7828   int sp;
7829   int dfsnum = 0;
7830   int rcnum = n_basic_blocks - 1;
7831   sbitmap visited;
7832
7833   /* Allocate stack for back-tracking up CFG.  */
7834   stack = (edge *) xmalloc ((n_basic_blocks + 1) * sizeof (edge));
7835   sp = 0;
7836
7837   /* Allocate bitmap to track nodes that have been visited.  */
7838   visited = sbitmap_alloc (n_basic_blocks);
7839
7840   /* None of the nodes in the CFG have been visited yet.  */
7841   sbitmap_zero (visited);
7842
7843   /* Push the first edge on to the stack.  */
7844   stack[sp++] = ENTRY_BLOCK_PTR->succ;
7845
7846   while (sp)
7847     {
7848       edge e;
7849       basic_block src;
7850       basic_block dest;
7851
7852       /* Look at the edge on the top of the stack.  */
7853       e = stack[sp - 1];
7854       src = e->src;
7855       dest = e->dest;
7856
7857       /* Check if the edge destination has been visited yet.  */
7858       if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index))
7859         {
7860           /* Mark that we have visited the destination.  */
7861           SET_BIT (visited, dest->index);
7862
7863           if (dfs_order)
7864             dfs_order[dfsnum++] = dest->index;
7865
7866           if (dest->succ)
7867             {
7868               /* Since the DEST node has been visited for the first
7869                  time, check its successors.  */
7870               stack[sp++] = dest->succ;
7871             }
7872           else
7873             {
7874               /* There are no successors for the DEST node so assign
7875                  its reverse completion number.  */
7876               if (rc_order)
7877                 rc_order[rcnum--] = dest->index;
7878             }
7879         }
7880       else
7881         {
7882           if (! e->succ_next && src != ENTRY_BLOCK_PTR)
7883             {
7884               /* There are no more successors for the SRC node
7885                  so assign its reverse completion number.  */
7886               if (rc_order)
7887                 rc_order[rcnum--] = src->index;
7888             }
7889
7890           if (e->succ_next)
7891             stack[sp - 1] = e->succ_next;
7892           else
7893             sp--;
7894         }
7895     }
7896
7897   free (stack);
7898   sbitmap_free (visited);
7899
7900   /* The number of nodes visited should not be greater than
7901      n_basic_blocks.  */
7902   if (dfsnum > n_basic_blocks)
7903     abort ();
7904
7905   /* There are some nodes left in the CFG that are unreachable.  */
7906   if (dfsnum < n_basic_blocks)
7907     abort ();
7908   return dfsnum;
7909 }
7910
7911 /* Compute the depth first search order on the _reverse_ graph and
7912    store in the array DFS_ORDER, marking the nodes visited in VISITED.
7913    Returns the number of nodes visited.
7914
7915    The computation is split into three pieces:
7916
7917    flow_dfs_compute_reverse_init () creates the necessary data
7918    structures.
7919
7920    flow_dfs_compute_reverse_add_bb () adds a basic block to the data
7921    structures.  The block will start the search.
7922
7923    flow_dfs_compute_reverse_execute () continues (or starts) the
7924    search using the block on the top of the stack, stopping when the
7925    stack is empty.
7926
7927    flow_dfs_compute_reverse_finish () destroys the necessary data
7928    structures.
7929
7930    Thus, the user will probably call ..._init(), call ..._add_bb() to
7931    add a beginning basic block to the stack, call ..._execute(),
7932    possibly add another bb to the stack and again call ..._execute(),
7933    ..., and finally call _finish().  */
7934
7935 /* Initialize the data structures used for depth-first search on the
7936    reverse graph.  If INITIALIZE_STACK is nonzero, the exit block is
7937    added to the basic block stack.  DATA is the current depth-first
7938    search context.  If INITIALIZE_STACK is non-zero, there is an
7939    element on the stack.  */
7940
7941 static void
7942 flow_dfs_compute_reverse_init (data)
7943      depth_first_search_ds data;
7944 {
7945   /* Allocate stack for back-tracking up CFG.  */
7946   data->stack =
7947     (basic_block *) xmalloc ((n_basic_blocks - (INVALID_BLOCK + 1))
7948                              * sizeof (basic_block));
7949   data->sp = 0;
7950
7951   /* Allocate bitmap to track nodes that have been visited.  */
7952   data->visited_blocks = sbitmap_alloc (n_basic_blocks - (INVALID_BLOCK + 1));
7953
7954   /* None of the nodes in the CFG have been visited yet.  */
7955   sbitmap_zero (data->visited_blocks);
7956
7957   return;
7958 }
7959
7960 /* Add the specified basic block to the top of the dfs data
7961    structures.  When the search continues, it will start at the
7962    block.  */
7963
7964 static void
7965 flow_dfs_compute_reverse_add_bb (data, bb)
7966      depth_first_search_ds data;
7967      basic_block bb;
7968 {
7969   data->stack[data->sp++] = bb;
7970   return;
7971 }
7972
7973 /* Continue the depth-first search through the reverse graph starting
7974    with the block at the stack's top and ending when the stack is
7975    empty.  Visited nodes are marked.  Returns an unvisited basic
7976    block, or NULL if there is none available.  */
7977
7978 static basic_block
7979 flow_dfs_compute_reverse_execute (data)
7980      depth_first_search_ds data;
7981 {
7982   basic_block bb;
7983   edge e;
7984   int i;
7985
7986   while (data->sp > 0)
7987     {
7988       bb = data->stack[--data->sp];
7989
7990       /* Mark that we have visited this node.  */
7991       if (!TEST_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK + 1)))
7992         {
7993           SET_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK + 1));
7994
7995           /* Perform depth-first search on adjacent vertices.  */
7996           for (e = bb->pred; e; e = e->pred_next)
7997             flow_dfs_compute_reverse_add_bb (data, e->src);
7998         }
7999     }
8000
8001   /* Determine if there are unvisited basic blocks.  */
8002   for (i = n_basic_blocks - (INVALID_BLOCK + 1); --i >= 0;)
8003     if (!TEST_BIT (data->visited_blocks, i))
8004       return BASIC_BLOCK (i + (INVALID_BLOCK + 1));
8005   return NULL;
8006 }
8007
8008 /* Destroy the data structures needed for depth-first search on the
8009    reverse graph.  */
8010
8011 static void
8012 flow_dfs_compute_reverse_finish (data)
8013      depth_first_search_ds data;
8014 {
8015   free (data->stack);
8016   sbitmap_free (data->visited_blocks);
8017   return;
8018 }
8019
8020
8021 /* Find the root node of the loop pre-header extended basic block and
8022    the edges along the trace from the root node to the loop header.  */
8023
8024 static void
8025 flow_loop_pre_header_scan (loop)
8026      struct loop *loop;
8027 {
8028   int num = 0;
8029   basic_block ebb;
8030
8031   loop->num_pre_header_edges = 0;
8032
8033   if (loop->num_entries != 1)
8034      return;
8035
8036   ebb = loop->entry_edges[0]->src;
8037
8038   if (ebb != ENTRY_BLOCK_PTR)
8039     {
8040       edge e;
8041
8042       /* Count number of edges along trace from loop header to
8043          root of pre-header extended basic block.  Usually this is
8044          only one or two edges. */
8045       num++;
8046       while (ebb->pred->src != ENTRY_BLOCK_PTR && ! ebb->pred->pred_next)
8047         {
8048           ebb = ebb->pred->src;
8049           num++;
8050         }
8051
8052       loop->pre_header_edges = (edge *) xmalloc (num * sizeof (edge *));
8053       loop->num_pre_header_edges = num;
8054
8055       /* Store edges in order that they are followed.   The source
8056          of the first edge is the root node of the pre-header extended
8057          basic block and the destination of the last last edge is
8058          the loop header.  */
8059       for (e = loop->entry_edges[0]; num; e = e->src->pred)
8060         {
8061           loop->pre_header_edges[--num] = e;
8062         }
8063     }
8064 }
8065
8066
8067 /* Return the block for the pre-header of the loop with header
8068    HEADER where DOM specifies the dominator information.  Return NULL if
8069    there is no pre-header.  */
8070
8071 static basic_block
8072 flow_loop_pre_header_find (header, dom)
8073      basic_block header;
8074      const sbitmap *dom;
8075 {
8076   basic_block pre_header;
8077   edge e;
8078
8079   /* If block p is a predecessor of the header and is the only block
8080      that the header does not dominate, then it is the pre-header.  */
8081   pre_header = NULL;
8082   for (e = header->pred; e; e = e->pred_next)
8083     {
8084       basic_block node = e->src;
8085
8086       if (node != ENTRY_BLOCK_PTR
8087           && ! TEST_BIT (dom[node->index], header->index))
8088         {
8089           if (pre_header == NULL)
8090             pre_header = node;
8091           else
8092             {
8093               /* There are multiple edges into the header from outside
8094                  the loop so there is no pre-header block.  */
8095               pre_header = NULL;
8096               break;
8097             }
8098         }
8099     }
8100   return pre_header;
8101 }
8102
8103 /* Add LOOP to the loop hierarchy tree where PREVLOOP was the loop
8104    previously added.  The insertion algorithm assumes that the loops
8105    are added in the order found by a depth first search of the CFG.  */
8106
8107 static void
8108 flow_loop_tree_node_add (prevloop, loop)
8109      struct loop *prevloop;
8110      struct loop *loop;
8111 {
8112
8113   if (flow_loop_nested_p (prevloop, loop))
8114     {
8115       prevloop->inner = loop;
8116       loop->outer = prevloop;
8117       return;
8118     }
8119
8120   while (prevloop->outer)
8121     {
8122       if (flow_loop_nested_p (prevloop->outer, loop))
8123         {
8124           prevloop->next = loop;
8125           loop->outer = prevloop->outer;
8126           return;
8127         }
8128       prevloop = prevloop->outer;
8129     }
8130
8131   prevloop->next = loop;
8132   loop->outer = NULL;
8133 }
8134
8135 /* Build the loop hierarchy tree for LOOPS.  */
8136
8137 static void
8138 flow_loops_tree_build (loops)
8139      struct loops *loops;
8140 {
8141   int i;
8142   int num_loops;
8143
8144   num_loops = loops->num;
8145   if (! num_loops)
8146     return;
8147
8148   /* Root the loop hierarchy tree with the first loop found.
8149      Since we used a depth first search this should be the
8150      outermost loop.  */
8151   loops->tree = &loops->array[0];
8152   loops->tree->outer = loops->tree->inner = loops->tree->next = NULL;
8153
8154   /* Add the remaining loops to the tree.  */
8155   for (i = 1; i < num_loops; i++)
8156     flow_loop_tree_node_add (&loops->array[i - 1], &loops->array[i]);
8157 }
8158
8159 /* Helper function to compute loop nesting depth and enclosed loop level
8160    for the natural loop specified by LOOP at the loop depth DEPTH.
8161    Returns the loop level.  */
8162
8163 static int
8164 flow_loop_level_compute (loop, depth)
8165      struct loop *loop;
8166      int depth;
8167 {
8168   struct loop *inner;
8169   int level = 1;
8170
8171   if (! loop)
8172     return 0;
8173
8174   /* Traverse loop tree assigning depth and computing level as the
8175      maximum level of all the inner loops of this loop.  The loop
8176      level is equivalent to the height of the loop in the loop tree
8177      and corresponds to the number of enclosed loop levels (including
8178      itself).  */
8179   for (inner = loop->inner; inner; inner = inner->next)
8180     {
8181       int ilevel;
8182
8183       ilevel = flow_loop_level_compute (inner, depth + 1) + 1;
8184
8185       if (ilevel > level)
8186         level = ilevel;
8187     }
8188   loop->level = level;
8189   loop->depth = depth;
8190   return level;
8191 }
8192
8193 /* Compute the loop nesting depth and enclosed loop level for the loop
8194    hierarchy tree specfied by LOOPS.  Return the maximum enclosed loop
8195    level.  */
8196
8197 static int
8198 flow_loops_level_compute (loops)
8199      struct loops *loops;
8200 {
8201   struct loop *loop;
8202   int level;
8203   int levels = 0;
8204
8205   /* Traverse all the outer level loops.  */
8206   for (loop = loops->tree; loop; loop = loop->next)
8207     {
8208       level = flow_loop_level_compute (loop, 1);
8209       if (level > levels)
8210         levels = level;
8211     }
8212   return levels;
8213 }
8214
8215
8216 /* Scan a single natural loop specified by LOOP collecting information
8217    about it specified by FLAGS.  */
8218
8219 int
8220 flow_loop_scan (loops, loop, flags)
8221      struct loops *loops;
8222      struct loop *loop;
8223      int flags;
8224 {
8225   /* Determine prerequisites.  */
8226   if ((flags & LOOP_EXITS_DOMS) && ! loop->exit_edges)
8227     flags |= LOOP_EXIT_EDGES;
8228
8229   if (flags & LOOP_ENTRY_EDGES)
8230     {
8231       /* Find edges which enter the loop header.
8232          Note that the entry edges should only
8233          enter the header of a natural loop.  */
8234       loop->num_entries
8235         = flow_loop_entry_edges_find (loop->header,
8236                                       loop->nodes,
8237                                       &loop->entry_edges);
8238     }
8239
8240   if (flags & LOOP_EXIT_EDGES)
8241     {
8242       /* Find edges which exit the loop.  */
8243       loop->num_exits
8244         = flow_loop_exit_edges_find (loop->nodes,
8245                                      &loop->exit_edges);
8246     }
8247
8248   if (flags & LOOP_EXITS_DOMS)
8249     {
8250       int j;
8251
8252       /* Determine which loop nodes dominate all the exits
8253          of the loop.  */
8254       loop->exits_doms = sbitmap_alloc (n_basic_blocks);
8255       sbitmap_copy (loop->exits_doms, loop->nodes);
8256       for (j = 0; j < loop->num_exits; j++)
8257         sbitmap_a_and_b (loop->exits_doms, loop->exits_doms,
8258                          loops->cfg.dom[loop->exit_edges[j]->src->index]);
8259
8260       /* The header of a natural loop must dominate
8261          all exits.  */
8262       if (! TEST_BIT (loop->exits_doms, loop->header->index))
8263         abort ();
8264     }
8265
8266   if (flags & LOOP_PRE_HEADER)
8267     {
8268       /* Look to see if the loop has a pre-header node.  */
8269       loop->pre_header
8270         = flow_loop_pre_header_find (loop->header, loops->cfg.dom);
8271
8272       /* Find the blocks within the extended basic block of
8273          the loop pre-header.  */
8274       flow_loop_pre_header_scan (loop);
8275     }
8276   return 1;
8277 }
8278
8279
8280 /* Find all the natural loops in the function and save in LOOPS structure
8281    and recalculate loop_depth information in basic block structures.
8282    FLAGS controls which loop information is collected.
8283    Return the number of natural loops found.  */
8284
8285 int
8286 flow_loops_find (loops, flags)
8287      struct loops *loops;
8288      int flags;
8289 {
8290   int i;
8291   int b;
8292   int num_loops;
8293   edge e;
8294   sbitmap headers;
8295   sbitmap *dom;
8296   int *dfs_order;
8297   int *rc_order;
8298
8299   /* This function cannot be repeatedly called with different
8300      flags to build up the loop information.  The loop tree
8301      must always be built if this function is called.  */
8302   if (! (flags & LOOP_TREE))
8303     abort ();
8304
8305   memset (loops, 0, sizeof (*loops));
8306
8307   /* Taking care of this degenerate case makes the rest of
8308      this code simpler.  */
8309   if (n_basic_blocks == 0)
8310     return 0;
8311
8312   dfs_order = NULL;
8313   rc_order = NULL;
8314
8315   /* Compute the dominators.  */
8316   dom = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
8317   calculate_dominance_info (NULL, dom, CDI_DOMINATORS);
8318
8319   /* Count the number of loop edges (back edges).  This should be the
8320      same as the number of natural loops.  */
8321
8322   num_loops = 0;
8323   for (b = 0; b < n_basic_blocks; b++)
8324     {
8325       basic_block header;
8326
8327       header = BASIC_BLOCK (b);
8328       header->loop_depth = 0;
8329
8330       for (e = header->pred; e; e = e->pred_next)
8331         {
8332           basic_block latch = e->src;
8333
8334           /* Look for back edges where a predecessor is dominated
8335              by this block.  A natural loop has a single entry
8336              node (header) that dominates all the nodes in the
8337              loop.  It also has single back edge to the header
8338              from a latch node.  Note that multiple natural loops
8339              may share the same header.  */
8340           if (b != header->index)
8341             abort ();
8342
8343           if (latch != ENTRY_BLOCK_PTR && TEST_BIT (dom[latch->index], b))
8344             num_loops++;
8345         }
8346     }
8347
8348   if (num_loops)
8349     {
8350       /* Compute depth first search order of the CFG so that outer
8351          natural loops will be found before inner natural loops.  */
8352       dfs_order = (int *) xmalloc (n_basic_blocks * sizeof (int));
8353       rc_order = (int *) xmalloc (n_basic_blocks * sizeof (int));
8354       flow_depth_first_order_compute (dfs_order, rc_order);
8355
8356       /* Save CFG derived information to avoid recomputing it.  */
8357       loops->cfg.dom = dom;
8358       loops->cfg.dfs_order = dfs_order;
8359       loops->cfg.rc_order = rc_order;
8360
8361       /* Allocate loop structures.  */
8362       loops->array
8363         = (struct loop *) xcalloc (num_loops, sizeof (struct loop));
8364
8365       headers = sbitmap_alloc (n_basic_blocks);
8366       sbitmap_zero (headers);
8367
8368       loops->shared_headers = sbitmap_alloc (n_basic_blocks);
8369       sbitmap_zero (loops->shared_headers);
8370
8371       /* Find and record information about all the natural loops
8372          in the CFG.  */
8373       num_loops = 0;
8374       for (b = 0; b < n_basic_blocks; b++)
8375         {
8376           basic_block header;
8377
8378           /* Search the nodes of the CFG in reverse completion order
8379              so that we can find outer loops first.  */
8380           header = BASIC_BLOCK (rc_order[b]);
8381
8382           /* Look for all the possible latch blocks for this header.  */
8383           for (e = header->pred; e; e = e->pred_next)
8384             {
8385               basic_block latch = e->src;
8386
8387               /* Look for back edges where a predecessor is dominated
8388                  by this block.  A natural loop has a single entry
8389                  node (header) that dominates all the nodes in the
8390                  loop.  It also has single back edge to the header
8391                  from a latch node.  Note that multiple natural loops
8392                  may share the same header.  */
8393               if (latch != ENTRY_BLOCK_PTR
8394                   && TEST_BIT (dom[latch->index], header->index))
8395                 {
8396                   struct loop *loop;
8397
8398                   loop = loops->array + num_loops;
8399
8400                   loop->header = header;
8401                   loop->latch = latch;
8402                   loop->num = num_loops;
8403
8404                   num_loops++;
8405                 }
8406             }
8407         }
8408
8409       for (i = 0; i < num_loops; i++)
8410         {
8411           struct loop *loop = &loops->array[i];
8412
8413           /* Keep track of blocks that are loop headers so
8414              that we can tell which loops should be merged.  */
8415           if (TEST_BIT (headers, loop->header->index))
8416             SET_BIT (loops->shared_headers, loop->header->index);
8417           SET_BIT (headers, loop->header->index);
8418
8419           /* Find nodes contained within the loop.  */
8420           loop->nodes = sbitmap_alloc (n_basic_blocks);
8421           loop->num_nodes
8422             = flow_loop_nodes_find (loop->header, loop->latch, loop->nodes);
8423
8424           /* Compute first and last blocks within the loop.
8425              These are often the same as the loop header and
8426              loop latch respectively, but this is not always
8427              the case.  */
8428           loop->first
8429             = BASIC_BLOCK (sbitmap_first_set_bit (loop->nodes));
8430           loop->last
8431             = BASIC_BLOCK (sbitmap_last_set_bit (loop->nodes));
8432
8433           flow_loop_scan (loops, loop, flags);
8434         }
8435
8436       /* Natural loops with shared headers may either be disjoint or
8437          nested.  Disjoint loops with shared headers cannot be inner
8438          loops and should be merged.  For now just mark loops that share
8439          headers.  */
8440       for (i = 0; i < num_loops; i++)
8441         if (TEST_BIT (loops->shared_headers, loops->array[i].header->index))
8442           loops->array[i].shared = 1;
8443
8444       sbitmap_free (headers);
8445     }
8446
8447   loops->num = num_loops;
8448
8449   /* Build the loop hierarchy tree.  */
8450   flow_loops_tree_build (loops);
8451
8452   /* Assign the loop nesting depth and enclosed loop level for each
8453      loop.  */
8454   loops->levels = flow_loops_level_compute (loops);
8455
8456   return num_loops;
8457 }
8458
8459
8460 /* Update the information regarding the loops in the CFG
8461    specified by LOOPS.  */
8462 int
8463 flow_loops_update (loops, flags)
8464      struct loops *loops;
8465      int flags;
8466 {
8467   /* One day we may want to update the current loop data.  For now
8468      throw away the old stuff and rebuild what we need.  */
8469   if (loops->array)
8470     flow_loops_free (loops);
8471
8472   return flow_loops_find (loops, flags);
8473 }
8474
8475
8476 /* Return non-zero if edge E enters header of LOOP from outside of LOOP.  */
8477
8478 int
8479 flow_loop_outside_edge_p (loop, e)
8480      const struct loop *loop;
8481      edge e;
8482 {
8483   if (e->dest != loop->header)
8484     abort ();
8485   return (e->src == ENTRY_BLOCK_PTR)
8486     || ! TEST_BIT (loop->nodes, e->src->index);
8487 }
8488
8489 /* Clear LOG_LINKS fields of insns in a chain.
8490    Also clear the global_live_at_{start,end} fields of the basic block
8491    structures.  */
8492
8493 void
8494 clear_log_links (insns)
8495      rtx insns;
8496 {
8497   rtx i;
8498   int b;
8499
8500   for (i = insns; i; i = NEXT_INSN (i))
8501     if (INSN_P (i))
8502       LOG_LINKS (i) = 0;
8503
8504   for (b = 0; b < n_basic_blocks; b++)
8505     {
8506       basic_block bb = BASIC_BLOCK (b);
8507
8508       bb->global_live_at_start = NULL;
8509       bb->global_live_at_end = NULL;
8510     }
8511
8512   ENTRY_BLOCK_PTR->global_live_at_end = NULL;
8513   EXIT_BLOCK_PTR->global_live_at_start = NULL;
8514 }
8515
8516 /* Given a register bitmap, turn on the bits in a HARD_REG_SET that
8517    correspond to the hard registers, if any, set in that map.  This
8518    could be done far more efficiently by having all sorts of special-cases
8519    with moving single words, but probably isn't worth the trouble.  */
8520
8521 void
8522 reg_set_to_hard_reg_set (to, from)
8523      HARD_REG_SET *to;
8524      bitmap from;
8525 {
8526   int i;
8527
8528   EXECUTE_IF_SET_IN_BITMAP
8529     (from, 0, i,
8530      {
8531        if (i >= FIRST_PSEUDO_REGISTER)
8532          return;
8533        SET_HARD_REG_BIT (*to, i);
8534      });
8535 }
8536
8537 /* Called once at intialization time.  */
8538
8539 void
8540 init_flow ()
8541 {
8542   static int initialized;
8543
8544   if (!initialized)
8545     {
8546       gcc_obstack_init (&flow_obstack);
8547       flow_firstobj = (char *) obstack_alloc (&flow_obstack, 0);
8548       initialized = 1;
8549     }
8550   else
8551     {
8552       obstack_free (&flow_obstack, flow_firstobj);
8553       flow_firstobj = (char *) obstack_alloc (&flow_obstack, 0);
8554     }
8555 }