gcc/flow.c

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