re PR rtl-optimization/42575 (arm-eabi-gcc 64-bit multiply weirdness)

	PR rtl-optimization/42575
	* dce.c (word_dce_process_block): Renamed from byte_dce_process_block.
	Argument AU removed.  All callers changed.  Ignore artificial refs.
	Use return value of df_word_lr_simulate_defs to decide whether an insn
	is necessary.
	(fast_dce): Rename arg to WORD_LEVEL.
	(run_word_dce): Renamed from rest_of_handle_fast_byte_dce.  No longer
	static.
	(pass_fast_rtl_byte_dce): Delete.
	* dce.h (run_word_dce): Declare.
	* df-core.c (df_print_word_regset): Renamed from df_print_byteregset.
	All callers changed.  Simplify code to only deal with two-word regs.
	* df.h (DF_WORD_LR): Renamed from DF_BYTE_LR.
	(DF_WORD_LR_BB_INFO): Renamed from DF_BYTE_LR_BB_INFO.
	(DF_WORD_LR_IN): Renamed from DF_BYTE_LR_IN.
	(DF_WORD_LR_OUT): Renamed from DF_BYTE_LR_OUT.
	(struct df_word_lr_bb_info): Renamed from df_byte_lr_bb_info.
	(df_word_lr_mark_ref): Declare.
	(df_word_lr_add_problem, df_word_lr_mark_ref, df_word_lr_simulate_defs,
	df_word_lr_simulate_uses): Declare or rename from byte variants.
	(df_byte_lr_simulate_artificial_refs_at_top,
	df_byte_lr_simulate_artificial_refs_at_end, df_byte_lr_get_regno_start,
	df_byte_lr_get_regno_len, df_compute_accessed_bytes): Delete
	declarations.
	(df_word_lr_get_bb_info): Rename from df_byte_lr_get_bb_info.
	(enum df_mm): Delete.
	* df-byte-scan.c: Delete file.
	* df-problems.c (df_word_lr_problem_data): Renamed from
	df_byte_lr_problem_data, all members deleted except for
	WORD_LR_BITMAPS, which is renamed from BYTE_LR_BITMAPS.  Uses changed.
	(df_word_lr_expand_bitmap, df_byte_lr_simulate_artificial_refs_at_top,
	df_byte_lr_simulate_artificial_refs_at_end, df_byte_lr_get_regno_start,
	df_byte_lr_get_regno_len, df_byte_lr_check_regs,
	df_byte_lr_confluence_0): Delete functions.
	(df_word_lr_free_bb_info): Renamed from df_byte_lr_free_bb_info; all
	callers changed.
	(df_word_lr_alloc): Renamed from df_byte_lr_alloc; all callers changed.
	Don't initialize members that were deleted, don't try to discover data
	about registers.  Ignore hard regs.
	(df_word_lr_reset): Renamed from df_byte_lr_reset; all callers changed.
	(df_word_lr_mark_ref): New function.
	(df_word_lr_bb_local_compute): Renamed from
	df_byte_bb_lr_local_compute; all callers changed.  Use
	df_word_lr_mark_ref.  Assert that artificial refs don't include
	pseudos.  Ignore hard registers.
	(df_word_lr_local_compute): Renamed from df_byte_lr_local_compute.
	Assert that exit block uses don't contain pseudos.
	(df_word_lr_init): Renamed from df_byte_lr_init; all callers changed.
	(df_word_lr_confluence_n): Renamed from df_byte_lr_confluence_n; all
	callers changed.  Ignore hard regs.
	(df_word_lr_transfer_function): Renamed from
	df_byte_lr_transfer_function; all callers changed.
	(df_word_lr_free): Renamed from df_byte_lr_free; all callers changed.
	(df_word_lr_top_dump): Renamed from df_byte_lr_top_dump; all callers
	changed.
	(df_word_lr_bottom_dump): Renamed from df_byte_lr_bottom_dump; all
	callers changed.
	(problem_WORD_LR): Renamed from problem_BYTE_LR; uses changed;
	confluence operator 0 set to NULL.
	(df_word_lr_add_problem): Renamed from df_byte_lr_add_problem; all
	callers changed.
	(df_word_lr_simulate_defs): Renamed from df_byte_lr_simulate_defs.
	Return bool, true if bitmap changed or insn otherwise necessary.
	All callers changed.  Simplify using df_word_lr_mark_ref.
	(df_word_lr_simulate_uses): Renamed from df_byte_lr_simulate_uses;
	all callers changed.  Simplify using df_word_lr_mark_ref.
	* lower-subreg.c: Include "dce.h"
	(decompose_multiword_subregs): Call run_word_dce if df available.
	* Makefile.in (lower-subreg.o): Adjust dependencies.
	(df-byte-scan.o): Delete.
	* timevar.def (TV_DF_WORD_LR): Renamed from TV_DF_BYTE_LR.

From-SVN: r162678

1 files changed, 0 insertions, 340 deletions

diff --git a/gcc/df-byte-scan.c b/gcc/df-byte-scan.c
deleted file mode 100644
index 8271465..0000000
--- a/gcc/df-byte-scan.c
+++ /dev/null
@@ -1,340 +0,0 @@
-/* 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;
-}
-