+++ /dev/null
-/* Scanning of rtl byte level scanning for dataflow analysis.
- Copyright (C) 2008 Free Software Foundation, Inc.
- Contributed by Kenneth Zadeck (zadeck@naturalbridge.com).
-
-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/>. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-#include "rtl.h"
-#include "tm_p.h"
-#include "df.h"
-#include "output.h"
-#include "dbgcnt.h"
-
-/* The following suite of functions provides bytewise modeling of REFs
- which are struct df_ref. START_BYTE and LAST_BYTE are returned.
- These can be used as indexes into bitmaps. The indexes are
- normalized so that 0 is the lowest numbered byte, of the inner
- register according to the natural ordering of the machine.
-
- This code is designed to be used in backwards scans (which is, of
- course, the way all dataflow scanning should really be done). It
- would require a lot of reworking of the api to make it work in a
- forwards scanning world. */
-
-
-/* Helper for df_compute_accessed_bytes. Ref is some sort of extract.
- Return true if this effects the entire reg in REF. Return false if
- otherwise and set START_BYTE and LAST_BYTE. See the description of
- df_compute_accessed_bytes for a description of MM. */
-
-static bool
-df_compute_accessed_bytes_extract (df_ref ref,
- enum df_mm mm ,
- unsigned int *start_byte,
- unsigned int *last_byte)
-{
- int start;
- int last;
- rtx reg = DF_REF_REG (ref);
- enum machine_mode m1;
- int m1_size;
- enum machine_mode m2;
- int m2_size;
-
- /* (*_extract:M1 (reg:M2 X) WIDTH POS)
- (*_extract:M1 (subreg:M1 (reg:M2 X N) WIDTH POS)
-
- This is a bitfield extraction. The assignment clobbers/extracts
- exactly the bits named by WIDTH and POS and does not affect the
- other bits in register X. It is also technically possible that
- the bits asked for are longer than units per word. */
-
- int offset = DF_REF_EXTRACT_OFFSET (ref);
- int width = DF_REF_EXTRACT_WIDTH (ref);
-
- if (width == -1 || offset == -1)
- return true;
-
- m1 = DF_REF_EXTRACT_MODE (ref);
- m1_size = GET_MODE_SIZE (m1);
-
- gcc_assert (m1_size <= UNITS_PER_WORD);
-
- /* There is nothing to do if this is a pure big or small endian
- machine, but if the machine is a pastiche, we have to convert the
- bit offsets into byte offsets. This is only possible because we
- do not care about individual bits because this conversion may
- make the bits non-contiguous. */
- if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
- offset = GET_MODE_BITSIZE (m1_size) - (offset + width);
-
- /* The offset is now in the same order as the subreg_byte. */
- if (GET_CODE (reg) == SUBREG)
- {
- m2 = GET_MODE (SUBREG_REG (reg));
- m2_size = GET_MODE_SIZE (m2);
- if (m1_size > m2_size)
- /* If it is paradoxical, subreg_byte will be zero. */
- offset -= subreg_lowpart_offset (m2, m1) * BITS_PER_UNIT;
- else
- offset += SUBREG_BYTE (reg) * BITS_PER_UNIT;
- }
- else
- {
- m2 = GET_MODE (reg);
- m2_size = GET_MODE_SIZE (m2);
- }
-
- if (mm == DF_MM_MUST)
- {
- /* For defs (generally), count the byte only if the whole byte
- is touched. */
- start = (offset + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
- last = (width + offset) / BITS_PER_UNIT;
-
- /* In the case where there is nothing, start may be one larger
- than last, we canonize this to return zeros. This keeps
- computations of length from being negative. */
- if (start >= last)
- {
- start = 0;
- last = 0;
- }
- }
- else
- {
- /* For uses (generally), count the byte if any part of the byte
- is touched. */
- start = offset / BITS_PER_UNIT;
- last = (width + offset + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
- }
-
- /* Paradoxical truncation. */
- if (start < 0)
- start = 0;
- if (last > m2_size)
- last = m2_size;
-
- if (dump_file)
- fprintf (dump_file, " cpb extract regno=%d start=%d last=%d\n",
- DF_REF_REGNO (ref), start, last);
-
- *start_byte = start;
- *last_byte = last;
- return false;
-}
-
-
-/* Helper for df_compute_accessed_bytes. Ref is a strict_low_part.
- Return true if this effects the entire reg in REF. Return false if
- otherwise and set START_BYTE and LAST_BYTE. */
-
-static bool
-df_compute_accessed_bytes_strict_low_part (df_ref ref,
- unsigned int *start_byte,
- unsigned int *last_byte)
-{
- int start;
- int last;
- rtx reg = DF_REF_REG (ref);
- enum machine_mode m1;
- int m1_size;
- enum machine_mode m2;
- int m2_size;
- int offset;
-
- /* In order to accommodate multiword subregs of a hardreg, df_scan
- eats the subreg and it can only be found from the loc. */
- if (REG_P (reg))
- reg = *(DF_REF_LOC (ref));
-
- m1 = GET_MODE (reg);
- m1_size = GET_MODE_SIZE (m1);
- m2 = GET_MODE (SUBREG_REG (reg));
- m2_size = GET_MODE_SIZE (m2);
- offset = SUBREG_BYTE (reg);
-
- /* It does not seem to be meaningful to apply a strict_low_part of a
- paradoxical register. */
- gcc_assert (m1_size <= m2_size);
-
- /* (set (strict_low_part (subreg:M1 (reg:M2 X) N)) ...)
-
- This is a bitfield insertion. The assignment clobbers exactly the
- bits named by the subreg--the M1 bits at position N. It is also
- technically possible that the bits asked for are longer than units
- per word. */
-
- start = offset;
- last = offset + m1_size;
-
- if (dump_file)
- fprintf (dump_file, " cpb strict low part regno=%d start=%d last=%d\n",
- DF_REF_REGNO (ref), start, last);
-
- *start_byte = start;
- *last_byte = last;
- return false;
-}
-
-/* Helper for df_compute_accessed_bytes. Ref is a naked subreg.
- Return true if this effects the entire reg in REF. Return false if
- otherwise and set START_BYTE and LAST_BYTE. */
-
-static bool
-df_compute_accessed_bytes_subreg (df_ref ref, unsigned int *start_byte,
- unsigned int *last_byte)
-
-{
- /* (subreg:M1 (reg:M2 X) N) */
- int start;
- int last;
- rtx reg = DF_REF_REG (ref);
-
- enum machine_mode m1;
- int m1_size;
- enum machine_mode m2;
- int m2_size;
-
- /* In order to accommodate multiword subregs of a hardreg, df_scan
- eats the subreg and it can only be found from the loc. */
- if (REG_P (reg))
- reg = *(DF_REF_LOC (ref));
-
- m1 = GET_MODE (reg);
- m1_size = GET_MODE_SIZE (m1);
- m2 = GET_MODE (SUBREG_REG (reg));
- m2_size = GET_MODE_SIZE (m2);
-
- /* A simple paradoxical subreg just accesses the entire inner reg. */
- if (m1_size >= m2_size)
- return true;
-
- /* Defs and uses are different in the amount of the reg that touch. */
- if (DF_REF_REG_DEF_P (ref))
- {
- /* This is an lvalue. */
-
- if (m2_size > UNITS_PER_WORD)
- {
- /* The assignment clobbers UNITS_PER_WORD segments of X.
- Look at the bytes named by the subreg, and expand it to
- cover a UNITS_PER_WORD part of register X. That part of
- register X is clobbered, the rest is not.
-
- E.g., (subreg:SI (reg:DI X) 0), where UNITS_PER_WORD is the
- size of SImode, clobbers the first SImode part of X, and does
- not affect the second SImode part.
-
- E.g., (subreg:QI (reg:DI X) 0), where UNITS_PER_WORD is the
- size of SImode, clobbers the first SImode part of X, and does
- not affect the second SImode part. Here the QImode byte is
- expanded to a UNITS_PER_WORD portion of the register for
- purposes of determining what is clobbered.
-
- If this is an rvalue, then it touches just the bytes that it
- talks about. */
- int offset = SUBREG_BYTE (reg);
-
- start = offset & ~(UNITS_PER_WORD - 1);
- last = (offset + m1_size + UNITS_PER_WORD - 1)
- & ~(UNITS_PER_WORD - 1);
- }
- else
- /* Whole register size M2 equal to or smaller than
- UNITS_PER_WORD The assignment clobbers the entire register
- X. */
- return true;
- }
- else
- {
- /* This is an rvalue. It touches just the bytes they explicitly
- mentioned. */
- int offset = SUBREG_BYTE (reg);
- start = offset;
- last = start + m1_size;
- }
-
- if (dump_file)
- fprintf (dump_file, " cpb subreg regno=%d start=%d last=%d\n",
- DF_REF_REGNO (ref), start, last);
-
- *start_byte = start;
- *last_byte = last;
- return false;
-}
-
-
-/* Compute the set of affected bytes by a store to a pseudo to REF.
- MM is either DF_MM_MAY or DF_MM_MUST. This is only relevant for
- the extracts which are not aligned to byte boundaries. The
- DF_MM_MAY returns all of the bytes that any bit is set in and the
- DF_MM_MUST returns only the bytes that are completely covered. In
- general DF_MM_MAY is used for uses and DF_MM_MUST is used for defs,
- but there are exceptions such as the inner loop of the byte level
- dead code eliminator which needs DF_MM_MAY for the defs to see if
- it any possible bit could be used.
-
- If the store is to the whole register, just return TRUE, if it is
- to part of the register, return FALSE and set START_BYTE and
- LAST_BYTE properly. In the case where fabricated uses are passed
- in, START_BYTE and LAST_BYTE are set to 0 and false is returned.
- This means that this use can be ignored. */
-
-bool
-df_compute_accessed_bytes (df_ref ref, enum df_mm mm,
- unsigned int *start_byte,
- unsigned int *last_byte)
-{
- if (!dbg_cnt (df_byte_scan))
- return true;
-
- if (!DF_REF_REG_DEF_P (ref)
- && DF_REF_FLAGS_IS_SET (ref, DF_REF_READ_WRITE))
- {
- if (DF_REF_FLAGS_IS_SET (ref, DF_REF_PRE_POST_MODIFY))
- /* Pre/post modify/inc/dec always read and write the entire
- reg. */
- return true;
- else
- {
- /* DF_REF_READ_WRITE on a use (except for the
- DF_REF_PRE_POST_MODIFY) means that this use is fabricated
- from a def that is a partial set to a multiword reg.
- Here, we only model those cases precisely so the only one
- to consider is the use put on a auto inc and dec
- insns. */
- *start_byte = 0;
- *last_byte = 0;
- return false;
- }
- }
-
- if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT))
- return df_compute_accessed_bytes_extract (ref, mm, start_byte, last_byte);
- else if (DF_REF_FLAGS_IS_SET (ref, DF_REF_STRICT_LOW_PART))
- return df_compute_accessed_bytes_strict_low_part (ref,
- start_byte, last_byte);
- else if (GET_CODE (DF_REF_REG (ref)) == SUBREG)
- return df_compute_accessed_bytes_subreg (ref, start_byte, last_byte);
- return true;
-}
-
\f
/*----------------------------------------------------------------------------
- BYTE LEVEL LIVE REGISTERS
+ WORD LEVEL LIVE REGISTERS
Find the locations in the function where any use of a pseudo can
reach in the backwards direction. In and out bitvectors are built
- for each basic block. There are two mapping functions,
- df_byte_lr_get_regno_start and df_byte_lr_get_regno_len that are
- used to map regnos into bit vector positions.
-
- This problem differs from the regular df_lr function in the way
- that subregs, *_extracts and strict_low_parts are handled. In lr
- these are consider partial kills, here, the exact set of bytes is
- modeled. Note that any reg that has none of these operations is
- only modeled with a single bit since all operations access the
- entire register.
-
- This problem is more brittle that the regular lr. It currently can
- be used in dce incrementally, but cannot be used in an environment
- where insns are created or modified. The problem is that the
- mapping of regnos to bitmap positions is relatively compact, in
- that if a pseudo does not do any of the byte wise operations, only
- one slot is allocated, rather than a slot for each byte. If insn
- are created, where a subreg is used for a reg that had no subregs,
- the mapping would be wrong. Likewise, there are no checks to see
- that new pseudos have been added. These issues could be addressed
- by adding a problem specific flag to not use the compact mapping,
- if there was a need to do so.
+ for each basic block. We only track pseudo registers that have a
+ size of 2 * UNITS_PER_WORD; bitmaps are indexed by 2 * regno and
+ contain two bits corresponding to each of the subwords.
----------------------------------------------------------------------------*/
/* Private data used to verify the solution for this problem. */
-struct df_byte_lr_problem_data
+struct df_word_lr_problem_data
{
- /* Expanded versions of bitvectors used in lr. */
- bitmap_head invalidated_by_call;
- bitmap_head hardware_regs_used;
-
- /* Indexed by regno, this is true if there are subregs, extracts or
- strict_low_parts for this regno. */
- bitmap_head needs_expansion;
-
- /* The start position and len for each regno in the various bit
- vectors. */
- unsigned int* regno_start;
- unsigned int* regno_len;
/* An obstack for the bitmaps we need for this problem. */
- bitmap_obstack byte_lr_bitmaps;
+ bitmap_obstack word_lr_bitmaps;
};
-/* Get the starting location for REGNO in the df_byte_lr bitmaps. */
-
-int
-df_byte_lr_get_regno_start (unsigned int regno)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;;
- return problem_data->regno_start[regno];
-}
-
-
-/* Get the len for REGNO in the df_byte_lr bitmaps. */
-
-int
-df_byte_lr_get_regno_len (unsigned int regno)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;;
- return problem_data->regno_len[regno];
-}
-
-
/* Free basic block info. */
static void
-df_byte_lr_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
+df_word_lr_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
void *vbb_info)
{
- struct df_byte_lr_bb_info *bb_info = (struct df_byte_lr_bb_info *) vbb_info;
+ struct df_word_lr_bb_info *bb_info = (struct df_word_lr_bb_info *) vbb_info;
if (bb_info)
{
bitmap_clear (&bb_info->use);
}
-/* Check all of the refs in REF_REC to see if any of them are
- extracts, subregs or strict_low_parts. */
-
-static void
-df_byte_lr_check_regs (df_ref *ref_rec)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
-
- for (; *ref_rec; ref_rec++)
- {
- df_ref ref = *ref_rec;
- if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT
- | DF_REF_ZERO_EXTRACT
- | DF_REF_STRICT_LOW_PART)
- || GET_CODE (DF_REF_REG (ref)) == SUBREG)
- bitmap_set_bit (&problem_data->needs_expansion, DF_REF_REGNO (ref));
- }
-}
-
-
-/* Expand bitmap SRC which is indexed by regno to DEST which is indexed by
- regno_start and regno_len. */
-
-static void
-df_byte_lr_expand_bitmap (bitmap dest, bitmap src)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- bitmap_iterator bi;
- unsigned int i;
-
- bitmap_clear (dest);
- EXECUTE_IF_SET_IN_BITMAP (src, 0, i, bi)
- {
- bitmap_set_range (dest, problem_data->regno_start[i],
- problem_data->regno_len[i]);
- }
-}
-
-
-/* Allocate or reset bitmaps for DF_BYTE_LR blocks. The solution bits are
+/* Allocate or reset bitmaps for DF_WORD_LR blocks. The solution bits are
not touched unless the block is new. */
static void
-df_byte_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
+df_word_lr_alloc (bitmap all_blocks ATTRIBUTE_UNUSED)
{
unsigned int bb_index;
bitmap_iterator bi;
basic_block bb;
- unsigned int regno;
- unsigned int index = 0;
- unsigned int max_reg = max_reg_num();
- struct df_byte_lr_problem_data *problem_data
- = XNEW (struct df_byte_lr_problem_data);
+ struct df_word_lr_problem_data *problem_data
+ = XNEW (struct df_word_lr_problem_data);
- df_byte_lr->problem_data = problem_data;
+ df_word_lr->problem_data = problem_data;
- df_grow_bb_info (df_byte_lr);
+ df_grow_bb_info (df_word_lr);
/* Create the mapping from regnos to slots. This does not change
unless the problem is destroyed and recreated. In particular, if
want to redo the mapping because this would invalidate everything
else. */
- bitmap_obstack_initialize (&problem_data->byte_lr_bitmaps);
- problem_data->regno_start = XNEWVEC (unsigned int, max_reg);
- problem_data->regno_len = XNEWVEC (unsigned int, max_reg);
- bitmap_initialize (&problem_data->hardware_regs_used,
- &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&problem_data->invalidated_by_call,
- &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&problem_data->needs_expansion,
- &problem_data->byte_lr_bitmaps);
-
- /* Discover which regno's use subregs, extracts or
- strict_low_parts. */
- FOR_EACH_BB (bb)
- {
- rtx insn;
- FOR_BB_INSNS (bb, insn)
- {
- if (INSN_P (insn))
- {
- struct df_insn_info *insn_info = DF_INSN_INFO_GET (insn);
- df_byte_lr_check_regs (DF_INSN_INFO_DEFS (insn_info));
- df_byte_lr_check_regs (DF_INSN_INFO_USES (insn_info));
- }
- }
- bitmap_set_bit (df_byte_lr->out_of_date_transfer_functions, bb->index);
- }
-
- bitmap_set_bit (df_byte_lr->out_of_date_transfer_functions, ENTRY_BLOCK);
- bitmap_set_bit (df_byte_lr->out_of_date_transfer_functions, EXIT_BLOCK);
+ bitmap_obstack_initialize (&problem_data->word_lr_bitmaps);
- /* Allocate the slots for each regno. */
- for (regno = 0; regno < max_reg; regno++)
- {
- int len;
- problem_data->regno_start[regno] = index;
- if (bitmap_bit_p (&problem_data->needs_expansion, regno))
- len = GET_MODE_SIZE (GET_MODE (regno_reg_rtx[regno]));
- else
- len = 1;
-
- problem_data->regno_len[regno] = len;
- index += len;
- }
+ FOR_EACH_BB (bb)
+ bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, bb->index);
- df_byte_lr_expand_bitmap (&problem_data->hardware_regs_used,
- &df->hardware_regs_used);
- df_byte_lr_expand_bitmap (&problem_data->invalidated_by_call,
- regs_invalidated_by_call_regset);
+ bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, ENTRY_BLOCK);
+ bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, EXIT_BLOCK);
- EXECUTE_IF_SET_IN_BITMAP (df_byte_lr->out_of_date_transfer_functions, 0, bb_index, bi)
+ EXECUTE_IF_SET_IN_BITMAP (df_word_lr->out_of_date_transfer_functions, 0, bb_index, bi)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
/* When bitmaps are already initialized, just clear them. */
if (bb_info->use.obstack)
}
else
{
- bitmap_initialize (&bb_info->use, &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&bb_info->def, &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&bb_info->in, &problem_data->byte_lr_bitmaps);
- bitmap_initialize (&bb_info->out, &problem_data->byte_lr_bitmaps);
+ bitmap_initialize (&bb_info->use, &problem_data->word_lr_bitmaps);
+ bitmap_initialize (&bb_info->def, &problem_data->word_lr_bitmaps);
+ bitmap_initialize (&bb_info->in, &problem_data->word_lr_bitmaps);
+ bitmap_initialize (&bb_info->out, &problem_data->word_lr_bitmaps);
}
}
- df_byte_lr->optional_p = true;
+ df_word_lr->optional_p = true;
}
/* Reset the global solution for recalculation. */
static void
-df_byte_lr_reset (bitmap all_blocks)
+df_word_lr_reset (bitmap all_blocks)
{
unsigned int bb_index;
bitmap_iterator bi;
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
gcc_assert (bb_info);
bitmap_clear (&bb_info->in);
bitmap_clear (&bb_info->out);
}
}
+/* Examine REF, and if it is for a reg we're interested in, set or
+ clear the bits corresponding to its subwords from the bitmap
+ according to IS_SET. LIVE is the bitmap we should update. We do
+ not track hard regs or pseudos of any size other than 2 *
+ UNITS_PER_WORD.
+ We return true if we changed the bitmap, or if we encountered a register
+ we're not tracking. */
+
+bool
+df_word_lr_mark_ref (df_ref ref, bool is_set, regset live)
+{
+ rtx orig_reg = DF_REF_REG (ref);
+ rtx reg = orig_reg;
+ enum machine_mode reg_mode;
+ unsigned regno;
+ /* Left at -1 for whole accesses. */
+ int which_subword = -1;
+ bool changed = false;
+
+ if (GET_CODE (reg) == SUBREG)
+ reg = SUBREG_REG (orig_reg);
+ regno = REGNO (reg);
+ reg_mode = GET_MODE (reg);
+ if (regno < FIRST_PSEUDO_REGISTER
+ || GET_MODE_SIZE (reg_mode) != 2 * UNITS_PER_WORD)
+ return true;
+
+ if (GET_CODE (orig_reg) == SUBREG
+ && df_read_modify_subreg_p (orig_reg))
+ {
+ gcc_assert (DF_REF_FLAGS_IS_SET (ref, DF_REF_PARTIAL));
+ if (subreg_lowpart_p (orig_reg))
+ which_subword = 0;
+ else
+ which_subword = 1;
+ }
+ if (is_set)
+ {
+ if (which_subword != 1)
+ changed |= bitmap_set_bit (live, regno * 2);
+ if (which_subword != 0)
+ changed |= bitmap_set_bit (live, regno * 2 + 1);
+ }
+ else
+ {
+ if (which_subword != 1)
+ changed |= bitmap_clear_bit (live, regno * 2);
+ if (which_subword != 0)
+ changed |= bitmap_clear_bit (live, regno * 2 + 1);
+ }
+ return changed;
+}
/* Compute local live register info for basic block BB. */
static void
-df_byte_lr_bb_local_compute (unsigned int bb_index)
+df_word_lr_bb_local_compute (unsigned int bb_index)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
basic_block bb = BASIC_BLOCK (bb_index);
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
rtx insn;
df_ref *def_rec;
df_ref *use_rec;
- /* Process the registers set in an exception handler. */
+ /* Ensure that artificial refs don't contain references to pseudos. */
for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
{
df_ref def = *def_rec;
- if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- bitmap_set_range (&bb_info->def, start, len);
- bitmap_clear_range (&bb_info->use, start, len);
- }
+ gcc_assert (DF_REF_REGNO (def) < FIRST_PSEUDO_REGISTER);
}
- /* Process the hardware registers that are always live. */
for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
{
df_ref use = *use_rec;
- /* Add use to set of uses in this BB. */
- if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
- {
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- bitmap_set_range (&bb_info->use, start, len);
- }
+ gcc_assert (DF_REF_REGNO (use) < FIRST_PSEUDO_REGISTER);
}
FOR_BB_INSNS_REVERSE (bb, insn)
if (!INSN_P (insn))
continue;
-
for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
{
df_ref def = *def_rec;
not kill the other defs that reach here. */
if (!(DF_REF_FLAGS (def) & (DF_REF_CONDITIONAL)))
{
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- unsigned int sb;
- unsigned int lb;
- if (!df_compute_accessed_bytes (def, DF_MM_MUST, &sb, &lb))
- {
- start += sb;
- len = lb - sb;
- }
- if (len)
- {
- bitmap_set_range (&bb_info->def, start, len);
- bitmap_clear_range (&bb_info->use, start, len);
- }
+ df_word_lr_mark_ref (def, true, &bb_info->def);
+ df_word_lr_mark_ref (def, false, &bb_info->use);
}
}
-
for (use_rec = DF_INSN_UID_USES (uid); *use_rec; use_rec++)
{
df_ref use = *use_rec;
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- unsigned int sb;
- unsigned int lb;
- if (!df_compute_accessed_bytes (use, DF_MM_MAY, &sb, &lb))
- {
- start += sb;
- len = lb - sb;
- }
- /* Add use to set of uses in this BB. */
- if (len)
- bitmap_set_range (&bb_info->use, start, len);
- }
- }
-
- /* Process the registers set in an exception handler or the hard
- frame pointer if this block is the target of a non local
- goto. */
- for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
- {
- df_ref def = *def_rec;
- if (DF_REF_FLAGS (def) & DF_REF_AT_TOP)
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- bitmap_set_range (&bb_info->def, start, len);
- bitmap_clear_range (&bb_info->use, start, len);
- }
- }
-
-#ifdef EH_USES
- /* Process the uses that are live into an exception handler. */
- for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
- {
- df_ref use = *use_rec;
- /* Add use to set of uses in this BB. */
- if (DF_REF_FLAGS (use) & DF_REF_AT_TOP)
- {
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- bitmap_set_range (&bb_info->use, start, len);
+ df_word_lr_mark_ref (use, true, &bb_info->use);
}
}
-#endif
}
/* Compute local live register info for each basic block within BLOCKS. */
static void
-df_byte_lr_local_compute (bitmap all_blocks ATTRIBUTE_UNUSED)
+df_word_lr_local_compute (bitmap all_blocks ATTRIBUTE_UNUSED)
{
unsigned int bb_index;
bitmap_iterator bi;
- EXECUTE_IF_SET_IN_BITMAP (df_byte_lr->out_of_date_transfer_functions, 0, bb_index, bi)
+ EXECUTE_IF_SET_IN_BITMAP (df_word_lr->out_of_date_transfer_functions, 0, bb_index, bi)
{
if (bb_index == EXIT_BLOCK)
{
- /* The exit block is special for this problem and its bits are
- computed from thin air. */
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (EXIT_BLOCK);
- df_byte_lr_expand_bitmap (&bb_info->use, df->exit_block_uses);
+ unsigned regno;
+ bitmap_iterator bi;
+ EXECUTE_IF_SET_IN_BITMAP (df->exit_block_uses, FIRST_PSEUDO_REGISTER,
+ regno, bi)
+ gcc_unreachable ();
}
else
- df_byte_lr_bb_local_compute (bb_index);
+ df_word_lr_bb_local_compute (bb_index);
}
- bitmap_clear (df_byte_lr->out_of_date_transfer_functions);
+ bitmap_clear (df_word_lr->out_of_date_transfer_functions);
}
/* Initialize the solution vectors. */
static void
-df_byte_lr_init (bitmap all_blocks)
+df_word_lr_init (bitmap all_blocks)
{
unsigned int bb_index;
bitmap_iterator bi;
EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
bitmap_copy (&bb_info->in, &bb_info->use);
bitmap_clear (&bb_info->out);
}
}
-/* Confluence function that processes infinite loops. This might be a
- noreturn function that throws. And even if it isn't, getting the
- unwind info right helps debugging. */
-static void
-df_byte_lr_confluence_0 (basic_block bb)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- bitmap op1 = &df_byte_lr_get_bb_info (bb->index)->out;
- if (bb != EXIT_BLOCK_PTR)
- bitmap_copy (op1, &problem_data->hardware_regs_used);
-}
-
-
/* Confluence function that ignores fake edges. */
static bool
-df_byte_lr_confluence_n (edge e)
+df_word_lr_confluence_n (edge e)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- bitmap op1 = &df_byte_lr_get_bb_info (e->src->index)->out;
- bitmap op2 = &df_byte_lr_get_bb_info (e->dest->index)->in;
- bool changed = false;
+ bitmap op1 = &df_word_lr_get_bb_info (e->src->index)->out;
+ bitmap op2 = &df_word_lr_get_bb_info (e->dest->index)->in;
- /* Call-clobbered registers die across exception and call edges. */
- /* ??? Abnormal call edges ignored for the moment, as this gets
- confused by sibling call edges, which crashes reg-stack. */
- if (e->flags & EDGE_EH)
- changed = bitmap_ior_and_compl_into (op1, op2,
- &problem_data->invalidated_by_call);
- else
- changed = bitmap_ior_into (op1, op2);
-
- changed |= bitmap_ior_into (op1, &problem_data->hardware_regs_used);
- return changed;
+ return bitmap_ior_into (op1, op2);
}
/* Transfer function. */
static bool
-df_byte_lr_transfer_function (int bb_index)
+df_word_lr_transfer_function (int bb_index)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb_index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
bitmap in = &bb_info->in;
bitmap out = &bb_info->out;
bitmap use = &bb_info->use;
/* Free all storage associated with the problem. */
static void
-df_byte_lr_free (void)
+df_word_lr_free (void)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
+ struct df_word_lr_problem_data *problem_data
+ = (struct df_word_lr_problem_data *)df_word_lr->problem_data;
-
- if (df_byte_lr->block_info)
+ if (df_word_lr->block_info)
{
- df_byte_lr->block_info_size = 0;
- free (df_byte_lr->block_info);
- df_byte_lr->block_info = NULL;
+ df_word_lr->block_info_size = 0;
+ free (df_word_lr->block_info);
+ df_word_lr->block_info = NULL;
}
- BITMAP_FREE (df_byte_lr->out_of_date_transfer_functions);
- bitmap_obstack_release (&problem_data->byte_lr_bitmaps);
- free (problem_data->regno_start);
- free (problem_data->regno_len);
+ BITMAP_FREE (df_word_lr->out_of_date_transfer_functions);
+ bitmap_obstack_release (&problem_data->word_lr_bitmaps);
free (problem_data);
- free (df_byte_lr);
+ free (df_word_lr);
}
/* Debugging info at top of bb. */
static void
-df_byte_lr_top_dump (basic_block bb, FILE *file)
+df_word_lr_top_dump (basic_block bb, FILE *file)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb->index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
if (!bb_info)
return;
fprintf (file, ";; blr in \t");
- df_print_byte_regset (file, &bb_info->in);
+ df_print_word_regset (file, &bb_info->in);
fprintf (file, ";; blr use \t");
- df_print_byte_regset (file, &bb_info->use);
+ df_print_word_regset (file, &bb_info->use);
fprintf (file, ";; blr def \t");
- df_print_byte_regset (file, &bb_info->def);
+ df_print_word_regset (file, &bb_info->def);
}
/* Debugging info at bottom of bb. */
static void
-df_byte_lr_bottom_dump (basic_block bb, FILE *file)
+df_word_lr_bottom_dump (basic_block bb, FILE *file)
{
- struct df_byte_lr_bb_info *bb_info = df_byte_lr_get_bb_info (bb->index);
+ struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
if (!bb_info)
return;
fprintf (file, ";; blr out \t");
- df_print_byte_regset (file, &bb_info->out);
+ df_print_word_regset (file, &bb_info->out);
}
/* All of the information associated with every instance of the problem. */
-static struct df_problem problem_BYTE_LR =
+static struct df_problem problem_WORD_LR =
{
- DF_BYTE_LR, /* Problem id. */
+ DF_WORD_LR, /* Problem id. */
DF_BACKWARD, /* Direction. */
- df_byte_lr_alloc, /* Allocate the problem specific data. */
- df_byte_lr_reset, /* Reset global information. */
- df_byte_lr_free_bb_info, /* Free basic block info. */
- df_byte_lr_local_compute, /* Local compute function. */
- df_byte_lr_init, /* Init the solution specific data. */
+ df_word_lr_alloc, /* Allocate the problem specific data. */
+ df_word_lr_reset, /* Reset global information. */
+ df_word_lr_free_bb_info, /* Free basic block info. */
+ df_word_lr_local_compute, /* Local compute function. */
+ df_word_lr_init, /* Init the solution specific data. */
df_worklist_dataflow, /* Worklist solver. */
- df_byte_lr_confluence_0, /* Confluence operator 0. */
- df_byte_lr_confluence_n, /* Confluence operator n. */
- df_byte_lr_transfer_function, /* Transfer function. */
+ NULL, /* Confluence operator 0. */
+ df_word_lr_confluence_n, /* Confluence operator n. */
+ df_word_lr_transfer_function, /* Transfer function. */
NULL, /* Finalize function. */
- df_byte_lr_free, /* Free all of the problem information. */
- df_byte_lr_free, /* Remove this problem from the stack of dataflow problems. */
+ df_word_lr_free, /* Free all of the problem information. */
+ df_word_lr_free, /* Remove this problem from the stack of dataflow problems. */
NULL, /* Debugging. */
- df_byte_lr_top_dump, /* Debugging start block. */
- df_byte_lr_bottom_dump, /* Debugging end block. */
+ df_word_lr_top_dump, /* Debugging start block. */
+ df_word_lr_bottom_dump, /* Debugging end block. */
NULL, /* Incremental solution verify start. */
NULL, /* Incremental solution verify end. */
NULL, /* Dependent problem. */
- sizeof (struct df_byte_lr_bb_info),/* Size of entry of block_info array. */
- TV_DF_BYTE_LR, /* Timing variable. */
+ sizeof (struct df_word_lr_bb_info),/* Size of entry of block_info array. */
+ TV_DF_WORD_LR, /* Timing variable. */
false /* Reset blocks on dropping out of blocks_to_analyze. */
};
solution. */
void
-df_byte_lr_add_problem (void)
+df_word_lr_add_problem (void)
{
- df_add_problem (&problem_BYTE_LR);
+ df_add_problem (&problem_WORD_LR);
/* These will be initialized when df_scan_blocks processes each
block. */
- df_byte_lr->out_of_date_transfer_functions = BITMAP_ALLOC (NULL);
+ df_word_lr->out_of_date_transfer_functions = BITMAP_ALLOC (NULL);
}
-/* Simulate the effects of the defs of INSN on LIVE. */
+/* Simulate the effects of the defs of INSN on LIVE. Return true if we changed
+ any bits, which is used by the caller to determine whether a set is
+ necessary. We also return true if there are other reasons not to delete
+ an insn. */
-void
-df_byte_lr_simulate_defs (rtx insn, bitmap live)
+bool
+df_word_lr_simulate_defs (rtx insn, bitmap live)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
+ bool changed = false;
df_ref *def_rec;
unsigned int uid = INSN_UID (insn);
for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++)
{
df_ref def = *def_rec;
-
- /* If the def is to only part of the reg, it does
- not kill the other defs that reach here. */
- if (!(DF_REF_FLAGS (def) & DF_REF_CONDITIONAL))
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- unsigned int sb;
- unsigned int lb;
- if (!df_compute_accessed_bytes (def, DF_MM_MUST, &sb, &lb))
- {
- start += sb;
- len = lb - sb;
- }
-
- if (len)
- bitmap_clear_range (live, start, len);
- }
+ if (DF_REF_FLAGS (def) & DF_REF_CONDITIONAL)
+ changed = true;
+ else
+ changed |= df_word_lr_mark_ref (*def_rec, false, live);
}
+ return changed;
}
/* Simulate the effects of the uses of INSN on LIVE. */
void
-df_byte_lr_simulate_uses (rtx insn, bitmap live)
+df_word_lr_simulate_uses (rtx insn, bitmap live)
{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
df_ref *use_rec;
unsigned int uid = INSN_UID (insn);
for (use_rec = DF_INSN_UID_USES (uid); *use_rec; use_rec++)
- {
- df_ref use = *use_rec;
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- unsigned int sb;
- unsigned int lb;
-
- if (!df_compute_accessed_bytes (use, DF_MM_MAY, &sb, &lb))
- {
- start += sb;
- len = lb - sb;
- }
-
- /* Add use to set of uses in this BB. */
- if (len)
- bitmap_set_range (live, start, len);
- }
-}
-
-
-/* Apply the artificial uses and defs at the top of BB in a forwards
- direction. */
-
-void
-df_byte_lr_simulate_artificial_refs_at_top (basic_block bb, bitmap live)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- df_ref *def_rec;
-#ifdef EH_USES
- df_ref *use_rec;
-#endif
- int bb_index = bb->index;
-
-#ifdef EH_USES
- for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
- {
- df_ref use = *use_rec;
- if (DF_REF_FLAGS (use) & DF_REF_AT_TOP)
- {
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- bitmap_set_range (live, start, len);
- }
- }
-#endif
-
- for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
- {
- df_ref def = *def_rec;
- if (DF_REF_FLAGS (def) & DF_REF_AT_TOP)
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- bitmap_clear_range (live, start, len);
- }
- }
+ df_word_lr_mark_ref (*use_rec, true, live);
}
-
-
-/* Apply the artificial uses and defs at the end of BB in a backwards
- direction. */
-
-void
-df_byte_lr_simulate_artificial_refs_at_end (basic_block bb, bitmap live)
-{
- struct df_byte_lr_problem_data *problem_data
- = (struct df_byte_lr_problem_data *)df_byte_lr->problem_data;
- df_ref *def_rec;
- df_ref *use_rec;
- int bb_index = bb->index;
-
- for (def_rec = df_get_artificial_defs (bb_index); *def_rec; def_rec++)
- {
- df_ref def = *def_rec;
- if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
- {
- unsigned int dregno = DF_REF_REGNO (def);
- unsigned int start = problem_data->regno_start[dregno];
- unsigned int len = problem_data->regno_len[dregno];
- bitmap_clear_range (live, start, len);
- }
- }
-
- for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
- {
- df_ref use = *use_rec;
- if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
- {
- unsigned int uregno = DF_REF_REGNO (use);
- unsigned int start = problem_data->regno_start[uregno];
- unsigned int len = problem_data->regno_len[uregno];
- bitmap_set_range (live, start, len);
- }
- }
-}
-
-
\f
/*----------------------------------------------------------------------------
This problem computes REG_DEAD and REG_UNUSED notes.
OSDN Git Service
