CbC/CbC_gcc: gcc/rtl.c comparison

comparison gcc/rtl.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 /* RTL utility routines.
 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
-2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+2003, 2004, 2005, 2006, 2007, 2008, 2009 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
 #endif
 return rt;
 }
+/* Create a bitwise copy of VEC.  */
+rtvec
+shallow_copy_rtvec (rtvec vec)
+{
+rtvec newvec;
+int n;
+n = GET_NUM_ELEM (vec);
+newvec = rtvec_alloc (n);
+memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n);
+return newvec;
+}
 /* Return the number of bytes occupied by rtx value X.  */
 unsigned int
 rtx_size (const_rtx x)
 {
 bool
 shared_const_p (const_rtx orig)
 {
 gcc_assert (GET_CODE (orig) == CONST);
 /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 a LABEL_REF, it isn't sharable.  */
 return (GET_CODE (XEXP (orig, 0)) == PLUS
 	  && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
-	  && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT);
+	  && CONST_INT_P(XEXP (XEXP (orig, 0), 1)));
 }
 /* Create a new copy of an rtx.
 Recursively copies the operands of the rtx,
 code = GET_CODE (orig);
 switch (code)
 {
 case REG:
+case DEBUG_EXPR:
+case VALUE:
 case CONST_INT:
 case CONST_DOUBLE:
 case CONST_FIXED:
 case CONST_VECTOR:
 case SYMBOL_REF:
 /* Nonzero when we are expanding trees to RTL.  */
 int currently_expanding_to_rtl;
 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
-When the callback returns true, we continue with the new pair.  */
+When the callback returns true, we continue with the new pair.
+Whenever changing this function check if rtx_equal_p below doesn't need
+changing as well.  */
 int
 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 {
 int i;
 (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 if (GET_MODE (x) != GET_MODE (y))
 return 0;
+/* MEMs refering to different address space are not equivalent.  */
+if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
+return 0;
 /* Some RTL can be compared nonrecursively.  */
 switch (code)
 {
 case REG:
 return (REGNO (x) == REGNO (y));
 return XEXP (x, 0) == XEXP (y, 0);
 case SYMBOL_REF:
 return XSTR (x, 0) == XSTR (y, 0);
+case DEBUG_EXPR:
+case VALUE:
 case SCRATCH:
 case CONST_DOUBLE:
 case CONST_INT:
 case CONST_FIXED:
 return 0;
 	  if (XVECLEN (x, i) != XVECLEN (y, i))
 	    return 0;
 	  /* And the corresponding elements must match.  */
 	  for (j = 0; j < XVECLEN (x, i); j++)
 	    if (rtx_equal_p_cb (XVECEXP (x, i, j),
 XVECEXP (y, i, j), cb) == 0)
 	      return 0;
 	  break;
 	case 'e':
 }
 return 1;
 }
 /* Return 1 if X and Y are identical-looking rtx's.
-This is the Lisp function EQUAL for rtx arguments.  */
+This is the Lisp function EQUAL for rtx arguments.
+Whenever changing this function check if rtx_equal_p_cb above doesn't need
+changing as well.  */
 int
 rtx_equal_p (const_rtx x, const_rtx y)
 {
-return rtx_equal_p_cb (x, y, NULL);
+int i;
+int j;
+enum rtx_code code;
+const char *fmt;
+if (x == y)
+return 1;
+if (x == 0 || y == 0)
+return 0;
+code = GET_CODE (x);
+/* Rtx's of different codes cannot be equal.  */
+if (code != GET_CODE (y))
+return 0;
+/* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
+(REG:SI x) and (REG:HI x) are NOT equivalent.  */
+if (GET_MODE (x) != GET_MODE (y))
+return 0;
+/* MEMs refering to different address space are not equivalent.  */
+if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
+return 0;
+/* Some RTL can be compared nonrecursively.  */
+switch (code)
+{
+case REG:
+return (REGNO (x) == REGNO (y));
+case LABEL_REF:
+return XEXP (x, 0) == XEXP (y, 0);
+case SYMBOL_REF:
+return XSTR (x, 0) == XSTR (y, 0);
+case DEBUG_EXPR:
+case VALUE:
+case SCRATCH:
+case CONST_DOUBLE:
+case CONST_INT:
+case CONST_FIXED:
+return 0;
+default:
+break;
+}
+/* Compare the elements.  If any pair of corresponding elements
+fail to match, return 0 for the whole thing.  */
+fmt = GET_RTX_FORMAT (code);
+for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+{
+switch (fmt[i])
+	{
+	case 'w':
+	  if (XWINT (x, i) != XWINT (y, i))
+	    return 0;
+	  break;
+	case 'n':
+	case 'i':
+	  if (XINT (x, i) != XINT (y, i))
+	    return 0;
+	  break;
+	case 'V':
+	case 'E':
+	  /* Two vectors must have the same length.  */
+	  if (XVECLEN (x, i) != XVECLEN (y, i))
+	    return 0;
+	  /* And the corresponding elements must match.  */
+	  for (j = 0; j < XVECLEN (x, i); j++)
+	    if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
+	      return 0;
+	  break;
+	case 'e':
+	  if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
+	    return 0;
+	  break;
+	case 'S':
+	case 's':
+	  if ((XSTR (x, i) || XSTR (y, i))
+	      && (! XSTR (x, i) || ! XSTR (y, i)
+		  || strcmp (XSTR (x, i), XSTR (y, i))))
+	    return 0;
+	  break;
+	case 'u':
+	  /* These are just backpointers, so they don't matter.  */
+	  break;
+	case '0':
+	case 't':
+	  break;
+	  /* It is believed that rtx's at this level will never
+	     contain anything but integers and other rtx's,
+	     except for within LABEL_REFs and SYMBOL_REFs.  */
+	default:
+	  gcc_unreachable ();
+	}
+}
+return 1;
 }
 void
 dump_rtx_statistics (void)
 {
 }
 fprintf (stderr, "---------------------------------------\n");
 fprintf (stderr, "%-20s %7d %10d\n",
 "Total", total_counts, total_sizes);
 fprintf (stderr, "---------------------------------------\n");
 #endif
 }
 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 void
 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,

Mercurial > hg > CbC > CbC_gcc

comparison gcc/rtl.c @ 55:77e2b8dfacca gcc-4.4.5