gcc/flow.c

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