Subversion Repositories openrisc_2011-10-31

/* Data flow analysis for GNU compiler.

   Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007

   Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

/* This file contains the data flow analysis pass of the compiler.  It

   computes data flow information which tells combine_instructions

   which insns to consider combining and controls register allocation.

   Additional data flow information that is too bulky to record is

   generated during the analysis, and is used at that time to create

   autoincrement and autodecrement addressing.

   The first step is dividing the function into basic blocks.

   find_basic_blocks does this.  Then life_analysis determines

   where each register is live and where it is dead.

   ** find_basic_blocks **

   find_basic_blocks divides the current function's rtl into basic

   blocks and constructs the CFG.  The blocks are recorded in the

   basic_block_info array; the CFG exists in the edge structures

   referenced by the blocks.

   find_basic_blocks also finds any unreachable loops and deletes them.

   ** life_analysis **

   life_analysis is called immediately after find_basic_blocks.

   It uses the basic block information to determine where each

   hard or pseudo register is live.

   ** live-register info **

   The information about where each register is live is in two parts:

   the REG_NOTES of insns, and the vector basic_block->global_live_at_start.

   basic_block->global_live_at_start has an element for each basic

   block, and the element is a bit-vector with a bit for each hard or

   pseudo register.  The bit is 1 if the register is live at the

   beginning of the basic block.

   Two types of elements can be added to an insn's REG_NOTES.

   A REG_DEAD note is added to an insn's REG_NOTES for any register

   that meets both of two conditions:  The value in the register is not

   needed in subsequent insns and the insn does not replace the value in

   the register (in the case of multi-word hard registers, the value in

   each register must be replaced by the insn to avoid a REG_DEAD note).

   In the vast majority of cases, an object in a REG_DEAD note will be

   used somewhere in the insn.  The (rare) exception to this is if an

   insn uses a multi-word hard register and only some of the registers are

   needed in subsequent insns.  In that case, REG_DEAD notes will be

   provided for those hard registers that are not subsequently needed.

   Partial REG_DEAD notes of this type do not occur when an insn sets

   only some of the hard registers used in such a multi-word operand;

   omitting REG_DEAD notes for objects stored in an insn is optional and

   the desire to do so does not justify the complexity of the partial

   REG_DEAD notes.

   REG_UNUSED notes are added for each register that is set by the insn

   but is unused subsequently (if every register set by the insn is unused

   and the insn does not reference memory or have some other side-effect,

   the insn is deleted instead).  If only part of a multi-word hard

   register is used in a subsequent insn, REG_UNUSED notes are made for

   the parts that will not be used.

   To determine which registers are live after any insn, one can

   start from the beginning of the basic block and scan insns, noting

   which registers are set by each insn and which die there.

   ** Other actions of life_analysis **

   life_analysis sets up the LOG_LINKS fields of insns because the

   information needed to do so is readily available.

   life_analysis deletes insns whose only effect is to store a value

   that is never used.

   life_analysis notices cases where a reference to a register as

   a memory address can be combined with a preceding or following

   incrementation or decrementation of the register.  The separate

   instruction to increment or decrement is deleted and the address

   is changed to a POST_INC or similar rtx.

   Each time an incrementing or decrementing address is created,

   a REG_INC element is added to the insn's REG_NOTES list.

   life_analysis fills in certain vectors containing information about

   register usage: REG_N_REFS, REG_N_DEATHS, REG_N_SETS, REG_LIVE_LENGTH,

   REG_N_CALLS_CROSSED, REG_N_THROWING_CALLS_CROSSED and REG_BASIC_BLOCK.

   life_analysis sets current_function_sp_is_unchanging if the function

   doesn't modify the stack pointer.  */

/* TODO:

   Split out from life_analysis:

        - local property discovery

        - global property computation

        - log links creation

        - pre/post modify transformation

*/

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "rtl.h"

#include "tm_p.h"

#include "hard-reg-set.h"

#include "basic-block.h"

#include "insn-config.h"

#include "regs.h"

#include "flags.h"

#include "output.h"

#include "function.h"

#include "except.h"

#include "toplev.h"

#include "recog.h"

#include "expr.h"

#include "timevar.h"

#include "obstack.h"

#include "splay-tree.h"

#include "tree-pass.h"

#include "params.h"

#ifndef HAVE_epilogue

#define HAVE_epilogue 0

#endif

#ifndef HAVE_prologue

#define HAVE_prologue 0

#endif

#ifndef HAVE_sibcall_epilogue

#define HAVE_sibcall_epilogue 0

#endif

#ifndef EPILOGUE_USES

#define EPILOGUE_USES(REGNO)  0

#endif

#ifndef EH_USES

#define EH_USES(REGNO)  0

#endif

#ifdef HAVE_conditional_execution

#ifndef REVERSE_CONDEXEC_PREDICATES_P

#define REVERSE_CONDEXEC_PREDICATES_P(x, y) \

  (GET_CODE ((x)) == reversed_comparison_code ((y), NULL))

#endif

#endif

/* This is the maximum number of times we process any given block if the

   latest loop depth count is smaller than this number.  Only used for the

   failure strategy to avoid infinite loops in calculate_global_regs_live.  */

#define MAX_LIVENESS_ROUNDS 20

/* Nonzero if the second flow pass has completed.  */

int flow2_completed;

/* Maximum register number used in this function, plus one.  */

int max_regno;

/* Indexed by n, giving various register information */

VEC(reg_info_p,heap) *reg_n_info;

/* Regset of regs live when calls to `setjmp'-like functions happen.  */

/* ??? Does this exist only for the setjmp-clobbered warning message?  */

static regset regs_live_at_setjmp;

/* List made of EXPR_LIST rtx's which gives pairs of pseudo registers

   that have to go in the same hard reg.

   The first two regs in the list are a pair, and the next two

   are another pair, etc.  */

rtx regs_may_share;

/* Set of registers that may be eliminable.  These are handled specially

   in updating regs_ever_live.  */

static HARD_REG_SET elim_reg_set;

/* Holds information for tracking conditional register life information.  */

struct reg_cond_life_info

{

  /* A boolean expression of conditions under which a register is dead.  */

  rtx condition;

  /* Conditions under which a register is dead at the basic block end.  */

  rtx orig_condition;

  /* A boolean expression of conditions under which a register has been

     stored into.  */

  rtx stores;

  /* ??? Could store mask of bytes that are dead, so that we could finally

     track lifetimes of multi-word registers accessed via subregs.  */

};

/* For use in communicating between propagate_block and its subroutines.

   Holds all information needed to compute life and def-use information.  */

struct propagate_block_info

{

  /* The basic block we're considering.  */

  basic_block bb;

  /* Bit N is set if register N is conditionally or unconditionally live.  */

  regset reg_live;

  /* Bit N is set if register N is set this insn.  */

  regset new_set;

  /* Element N is the next insn that uses (hard or pseudo) register N

     within the current basic block; or zero, if there is no such insn.  */

  rtx *reg_next_use;

  /* Contains a list of all the MEMs we are tracking for dead store

     elimination.  */

  rtx mem_set_list;

  /* If non-null, record the set of registers set unconditionally in the

     basic block.  */

  regset local_set;

  /* If non-null, record the set of registers set conditionally in the

     basic block.  */

  regset cond_local_set;

#ifdef HAVE_conditional_execution

  /* Indexed by register number, holds a reg_cond_life_info for each

     register that is not unconditionally live or dead.  */

  splay_tree reg_cond_dead;

  /* Bit N is set if register N is in an expression in reg_cond_dead.  */

  regset reg_cond_reg;

#endif

  /* The length of mem_set_list.  */

  int mem_set_list_len;

  /* Nonzero if the value of CC0 is live.  */

  int cc0_live;

  /* Flags controlling the set of information propagate_block collects.  */

  int flags;

  /* Index of instruction being processed.  */

  int insn_num;

};

/* Number of dead insns removed.  */

static int ndead;

/* When PROP_REG_INFO set, array contains pbi->insn_num of instruction

   where given register died.  When the register is marked alive, we use the

   information to compute amount of instructions life range cross.

   (remember, we are walking backward).  This can be computed as current

   pbi->insn_num - reg_deaths[regno].

   At the end of processing each basic block, the remaining live registers

   are inspected and live ranges are increased same way so liverange of global

   registers are computed correctly.

   The array is maintained clear for dead registers, so it can be safely reused

   for next basic block without expensive memset of the whole array after

   reseting pbi->insn_num to 0.  */

static int *reg_deaths;

/* Forward declarations */

static int verify_wide_reg_1 (rtx *, void *);

static void verify_wide_reg (int, basic_block);

static void verify_local_live_at_start (regset, basic_block);

static void notice_stack_pointer_modification_1 (rtx, rtx, void *);

static void notice_stack_pointer_modification (void);

static void mark_reg (rtx, void *);

static void mark_regs_live_at_end (regset);

static void calculate_global_regs_live (sbitmap, sbitmap, int);

static void propagate_block_delete_insn (rtx);

static rtx propagate_block_delete_libcall (rtx, rtx);

static int insn_dead_p (struct propagate_block_info *, rtx, int, rtx);

static int libcall_dead_p (struct propagate_block_info *, rtx, rtx);

static void mark_set_regs (struct propagate_block_info *, rtx, rtx);

static void mark_set_1 (struct propagate_block_info *, enum rtx_code, rtx,

                        rtx, rtx, int);

static int find_regno_partial (rtx *, void *);

#ifdef HAVE_conditional_execution

static int mark_regno_cond_dead (struct propagate_block_info *, int, rtx);

static void free_reg_cond_life_info (splay_tree_value);

static int flush_reg_cond_reg_1 (splay_tree_node, void *);

static void flush_reg_cond_reg (struct propagate_block_info *, int);

static rtx elim_reg_cond (rtx, unsigned int);

static rtx ior_reg_cond (rtx, rtx, int);

static rtx not_reg_cond (rtx);

static rtx and_reg_cond (rtx, rtx, int);

#endif

#ifdef AUTO_INC_DEC

static void attempt_auto_inc (struct propagate_block_info *, rtx, rtx, rtx,

                              rtx, rtx);

static void find_auto_inc (struct propagate_block_info *, rtx, rtx);

static int try_pre_increment_1 (struct propagate_block_info *, rtx);

static int try_pre_increment (rtx, rtx, HOST_WIDE_INT);

#endif

static void mark_used_reg (struct propagate_block_info *, rtx, rtx, rtx);

static void mark_used_regs (struct propagate_block_info *, rtx, rtx, rtx);

void debug_flow_info (void);

static void add_to_mem_set_list (struct propagate_block_info *, rtx);

static int invalidate_mems_from_autoinc (rtx *, void *);

static void invalidate_mems_from_set (struct propagate_block_info *, rtx);

static void clear_log_links (sbitmap);

static int count_or_remove_death_notes_bb (basic_block, int);

static void allocate_bb_life_data (void);

/* Return the INSN immediately following the NOTE_INSN_BASIC_BLOCK

   note associated with the BLOCK.  */

rtx

first_insn_after_basic_block_note (basic_block block)

{

  rtx insn;

  /* Get the first instruction in the block.  */

  insn = BB_HEAD (block);

  if (insn == NULL_RTX)

    return NULL_RTX;

  if (LABEL_P (insn))

    insn = NEXT_INSN (insn);

  gcc_assert (NOTE_INSN_BASIC_BLOCK_P (insn));

  return NEXT_INSN (insn);

}

/* Perform data flow analysis for the whole control flow graph.

   FLAGS is a set of PROP_* flags to be used in accumulating flow info.  */

void

life_analysis (int flags)

{

#ifdef ELIMINABLE_REGS

  int i;

  static const struct {const int from, to; } eliminables[] = ELIMINABLE_REGS;

#endif

  /* Record which registers will be eliminated.  We use this in

     mark_used_regs.  */

  CLEAR_HARD_REG_SET (elim_reg_set);

#ifdef ELIMINABLE_REGS

  for (i = 0; i < (int) ARRAY_SIZE (eliminables); i++)

    SET_HARD_REG_BIT (elim_reg_set, eliminables[i].from);

#else

  SET_HARD_REG_BIT (elim_reg_set, FRAME_POINTER_REGNUM);

#endif

#ifdef CANNOT_CHANGE_MODE_CLASS

  if (flags & PROP_REG_INFO)

    init_subregs_of_mode ();

#endif

  if (! optimize)

    flags &= ~(PROP_LOG_LINKS | PROP_AUTOINC | PROP_ALLOW_CFG_CHANGES);

  /* The post-reload life analysis have (on a global basis) the same

     registers live as was computed by reload itself.  elimination

     Otherwise offsets and such may be incorrect.

     Reload will make some registers as live even though they do not

     appear in the rtl.

     We don't want to create new auto-incs after reload, since they

     are unlikely to be useful and can cause problems with shared

     stack slots.  */

  if (reload_completed)

    flags &= ~(PROP_REG_INFO | PROP_AUTOINC);

  /* We want alias analysis information for local dead store elimination.  */

  if (optimize && (flags & PROP_SCAN_DEAD_STORES))

    init_alias_analysis ();

  /* Always remove no-op moves.  Do this before other processing so

     that we don't have to keep re-scanning them.  */

  delete_noop_moves ();

  /* Some targets can emit simpler epilogues if they know that sp was

     not ever modified during the function.  After reload, of course,

     we've already emitted the epilogue so there's no sense searching.  */

  if (! reload_completed)

    notice_stack_pointer_modification ();

  /* Allocate and zero out data structures that will record the

     data from lifetime analysis.  */

  allocate_reg_life_data ();

  allocate_bb_life_data ();

  /* Find the set of registers live on function exit.  */

  mark_regs_live_at_end (EXIT_BLOCK_PTR->il.rtl->global_live_at_start);

  /* "Update" life info from zero.  It'd be nice to begin the

     relaxation with just the exit and noreturn blocks, but that set

     is not immediately handy.  */

  if (flags & PROP_REG_INFO)

    {

      memset (regs_ever_live, 0, sizeof (regs_ever_live));

      memset (regs_asm_clobbered, 0, sizeof (regs_asm_clobbered));

    }

  update_life_info (NULL, UPDATE_LIFE_GLOBAL, flags);

  if (reg_deaths)

    {

      free (reg_deaths);

      reg_deaths = NULL;

    }

  /* Clean up.  */

  if (optimize && (flags & PROP_SCAN_DEAD_STORES))

    end_alias_analysis ();

  if (dump_file)

    dump_flow_info (dump_file, dump_flags);

  /* Removing dead insns should have made jumptables really dead.  */

  delete_dead_jumptables ();

}

/* A subroutine of verify_wide_reg, called through for_each_rtx.

   Search for REGNO.  If found, return 2 if it is not wider than

   word_mode.  */

static int

verify_wide_reg_1 (rtx *px, void *pregno)

{

  rtx x = *px;

  unsigned int regno = *(int *) pregno;

  if (REG_P (x) && REGNO (x) == regno)

    {

      if (GET_MODE_BITSIZE (GET_MODE (x)) <= BITS_PER_WORD)

        return 2;

      return 1;

    }

  return 0;

}

/* A subroutine of verify_local_live_at_start.  Search through insns

   of BB looking for register REGNO.  */

static void

verify_wide_reg (int regno, basic_block bb)

{

  rtx head = BB_HEAD (bb), end = BB_END (bb);

  while (1)

    {

      if (INSN_P (head))

        {

          int r = for_each_rtx (&PATTERN (head), verify_wide_reg_1, &regno);

          if (r == 1)

            return;

          if (r == 2)

            break;

        }

      if (head == end)

        break;

      head = NEXT_INSN (head);

    }

  if (dump_file)

    {

      fprintf (dump_file, "Register %d died unexpectedly.\n", regno);

      dump_bb (bb, dump_file, 0);

    }

  internal_error ("internal consistency failure");

}

/* A subroutine of update_life_info.  Verify that there are no untoward

   changes in live_at_start during a local update.  */

static void

verify_local_live_at_start (regset new_live_at_start, basic_block bb)

{

  if (reload_completed)

    {

      /* After reload, there are no pseudos, nor subregs of multi-word

         registers.  The regsets should exactly match.  */

      if (! REG_SET_EQUAL_P (new_live_at_start,

                             bb->il.rtl->global_live_at_start))

        {

          if (dump_file)

            {

              fprintf (dump_file,

                       "live_at_start mismatch in bb %d, aborting\nNew:\n",

                       bb->index);

              debug_bitmap_file (dump_file, new_live_at_start);

              fputs ("Old:\n", dump_file);

              dump_bb (bb, dump_file, 0);

            }

          internal_error ("internal consistency failure");

        }

    }

  else

    {

      unsigned i;

      reg_set_iterator rsi;

      /* Find the set of changed registers.  */

      XOR_REG_SET (new_live_at_start, bb->il.rtl->global_live_at_start);

      EXECUTE_IF_SET_IN_REG_SET (new_live_at_start, 0, i, rsi)

        {

          /* No registers should die.  */

          if (REGNO_REG_SET_P (bb->il.rtl->global_live_at_start, i))

            {

              if (dump_file)

                {

                  fprintf (dump_file,

                           "Register %d died unexpectedly.\n", i);

                  dump_bb (bb, dump_file, 0);

                }

              internal_error ("internal consistency failure");

            }

          /* Verify that the now-live register is wider than word_mode.  */

          verify_wide_reg (i, bb);

        }

    }

}

/* Updates life information starting with the basic blocks set in BLOCKS.

   If BLOCKS is null, consider it to be the universal set.

   If EXTENT is UPDATE_LIFE_LOCAL, such as after splitting or peepholing,

   we are only expecting local modifications to basic blocks.  If we find

   extra registers live at the beginning of a block, then we either killed

   useful data, or we have a broken split that wants data not provided.

   If we find registers removed from live_at_start, that means we have

   a broken peephole that is killing a register it shouldn't.

   ??? This is not true in one situation -- when a pre-reload splitter

   generates subregs of a multi-word pseudo, current life analysis will

   lose the kill.  So we _can_ have a pseudo go live.  How irritating.

   It is also not true when a peephole decides that it doesn't need one

   or more of the inputs.

   Including PROP_REG_INFO does not properly refresh regs_ever_live

   unless the caller resets it to zero.  */

int

update_life_info (sbitmap blocks, enum update_life_extent extent,

                  int prop_flags)

{

  regset tmp;

  unsigned i = 0;

  int stabilized_prop_flags = prop_flags;

  basic_block bb;

  tmp = ALLOC_REG_SET (&reg_obstack);

  ndead = 0;

  if ((prop_flags & PROP_REG_INFO) && !reg_deaths)

    reg_deaths = XCNEWVEC (int, max_regno);

  timevar_push ((extent == UPDATE_LIFE_LOCAL || blocks)

                ? TV_LIFE_UPDATE : TV_LIFE);

  /* Changes to the CFG are only allowed when

     doing a global update for the entire CFG.  */

  gcc_assert (!(prop_flags & PROP_ALLOW_CFG_CHANGES)

              || (extent != UPDATE_LIFE_LOCAL && !blocks));

  /* For a global update, we go through the relaxation process again.  */

  if (extent != UPDATE_LIFE_LOCAL)

    {

      for ( ; ; )

        {

          int changed = 0;

          calculate_global_regs_live (blocks, blocks,

                                prop_flags & (PROP_SCAN_DEAD_CODE

                                              | PROP_SCAN_DEAD_STORES

                                              | PROP_ALLOW_CFG_CHANGES));

          if ((prop_flags & (PROP_KILL_DEAD_CODE | PROP_ALLOW_CFG_CHANGES))

              != (PROP_KILL_DEAD_CODE | PROP_ALLOW_CFG_CHANGES))

            break;

          /* Removing dead code may allow the CFG to be simplified which

             in turn may allow for further dead code detection / removal.  */

          FOR_EACH_BB_REVERSE (bb)

            {

              COPY_REG_SET (tmp, bb->il.rtl->global_live_at_end);

              changed |= propagate_block (bb, tmp, NULL, NULL,

                                prop_flags & (PROP_SCAN_DEAD_CODE

                                              | PROP_SCAN_DEAD_STORES

                                              | PROP_KILL_DEAD_CODE));

            }

          /* Don't pass PROP_SCAN_DEAD_CODE or PROP_KILL_DEAD_CODE to

             subsequent propagate_block calls, since removing or acting as

             removing dead code can affect global register liveness, which

             is supposed to be finalized for this call after this loop.  */

          stabilized_prop_flags

            &= ~(PROP_SCAN_DEAD_CODE | PROP_SCAN_DEAD_STORES

                 | PROP_KILL_DEAD_CODE);

          if (! changed)

            break;

          /* We repeat regardless of what cleanup_cfg says.  If there were

             instructions deleted above, that might have been only a

             partial improvement (see PARAM_MAX_FLOW_MEMORY_LOCATIONS  usage).

             Further improvement may be possible.  */

          cleanup_cfg (CLEANUP_EXPENSIVE);

          /* Zap the life information from the last round.  If we don't

             do this, we can wind up with registers that no longer appear

             in the code being marked live at entry.  */

          FOR_EACH_BB (bb)

            {

              CLEAR_REG_SET (bb->il.rtl->global_live_at_start);

              CLEAR_REG_SET (bb->il.rtl->global_live_at_end);

            }

        }

      /* If asked, remove notes from the blocks we'll update.  */

      if (extent == UPDATE_LIFE_GLOBAL_RM_NOTES)

        count_or_remove_death_notes (blocks,

                                     prop_flags & PROP_POST_REGSTACK ? -1 : 1);

    }

  else

    {

      /* FIXME: This can go when the dataflow branch has been merged in.  */

      /* For a local update, if we are creating new REG_DEAD notes, then we

         must delete the old ones first to avoid conflicts if they are

         different.  */

      if (prop_flags & PROP_DEATH_NOTES)

        count_or_remove_death_notes (blocks,

                                     prop_flags & PROP_POST_REGSTACK ? -1 : 1);

    }

  /* Clear log links in case we are asked to (re)compute them.  */

  if (prop_flags & PROP_LOG_LINKS)

    clear_log_links (blocks);

  if (blocks)

    {

      sbitmap_iterator sbi;

      EXECUTE_IF_SET_IN_SBITMAP (blocks, 0, i, sbi)

        {

          bb = BASIC_BLOCK (i);

          if (bb)

            {

              /* The bitmap may be flawed in that one of the basic

                 blocks may have been deleted before you get here.  */

              COPY_REG_SET (tmp, bb->il.rtl->global_live_at_end);

              propagate_block (bb, tmp, NULL, NULL, stabilized_prop_flags);

              if (extent == UPDATE_LIFE_LOCAL)

                verify_local_live_at_start (tmp, bb);

            }

        };

    }

  else

    {

      FOR_EACH_BB_REVERSE (bb)

        {

          COPY_REG_SET (tmp, bb->il.rtl->global_live_at_end);

          propagate_block (bb, tmp, NULL, NULL, stabilized_prop_flags);

          if (extent == UPDATE_LIFE_LOCAL)

            verify_local_live_at_start (tmp, bb);

        }

    }

  FREE_REG_SET (tmp);

  if (prop_flags & PROP_REG_INFO)

    {

      reg_set_iterator rsi;

      /* The only pseudos that are live at the beginning of the function

         are those that were not set anywhere in the function.  local-alloc

         doesn't know how to handle these correctly, so mark them as not

         local to any one basic block.  */

      EXECUTE_IF_SET_IN_REG_SET (ENTRY_BLOCK_PTR->il.rtl->global_live_at_end,

                                 FIRST_PSEUDO_REGISTER, i, rsi)

        REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL;

      /* We have a problem with any pseudoreg that lives across the setjmp.

         ANSI says that if a user variable does not change in value between

         the setjmp and the longjmp, then the longjmp preserves it.  This

         includes longjmp from a place where the pseudo appears dead.

         (In principle, the value still exists if it is in scope.)

         If the pseudo goes in a hard reg, some other value may occupy

         that hard reg where this pseudo is dead, thus clobbering the pseudo.

         Conclusion: such a pseudo must not go in a hard reg.  */

      EXECUTE_IF_SET_IN_REG_SET (regs_live_at_setjmp,

                                 FIRST_PSEUDO_REGISTER, i, rsi)

        {

          if (regno_reg_rtx[i] != 0)

            {

              REG_LIVE_LENGTH (i) = -1;

              REG_BASIC_BLOCK (i) = REG_BLOCK_UNKNOWN;

            }

        }

    }

  if (reg_deaths)

    {

      free (reg_deaths);

      reg_deaths = NULL;

    }

  timevar_pop ((extent == UPDATE_LIFE_LOCAL || blocks)

               ? TV_LIFE_UPDATE : TV_LIFE);

  if (ndead && dump_file)

    fprintf (dump_file, "deleted %i dead insns\n", ndead);

  return ndead;

}

/* Update life information in all blocks where BB_DIRTY is set.  */

int

update_life_info_in_dirty_blocks (enum update_life_extent extent, int prop_flags)

{

  sbitmap update_life_blocks = sbitmap_alloc (last_basic_block);

  int n = 0;

  basic_block bb;

  int retval = 0;

  sbitmap_zero (update_life_blocks);

  FOR_EACH_BB (bb)

    {

      if (bb->flags & BB_DIRTY)