gcc/flow.c

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