From 6d9d0028e5fd4e6a21df223aa500bda28a90a81a Mon Sep 17 00:00:00 2001 From: Kenneth Zadeck Date: Mon, 21 Apr 2008 20:01:26 +0000 Subject: [PATCH] forgot to add this in last commit. From-SVN: r134528 --- gcc/df-byte-scan.c | 340 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 340 insertions(+) create mode 100644 gcc/df-byte-scan.c diff --git a/gcc/df-byte-scan.c b/gcc/df-byte-scan.c new file mode 100644 index 00000000000..c1c36197e59 --- /dev/null +++ b/gcc/df-byte-scan.c @@ -0,0 +1,340 @@ +/* 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 +. */ + +#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 (struct 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 (struct 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 accomodate 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 (struct 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 accomodate 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_TYPE (ref) == DF_REF_REG_DEF) + { + /* 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 (struct 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_TYPE (ref) != DF_REF_REG_DEF + && 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; +} + -- 2.30.2