gcc/flow.c

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