tree.c (save_expr): Allow either side of a dyadic operand to be constant.

	* tree.c (save_expr): Allow either side of a dyadic operand to be
	constant.

	* doc/portability.texi (portability): Update portability goals.

From-SVN: r60435

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 114be4503a81b7b12f56ef34e516917468f2dc80..ae22fbc4e59170bc047ecc4c25ab00145834d79e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2002-12-22  Nathan Sidwell  <nathan@codesourcery.com>
+
+       * tree.c (save_expr): Allow either side of a dyadic operand to be
+       constant.
+
+       * doc/portability.texi (portability): Update portability goals.
+
 2002-12-23  Kazu Hirata  <kazu@cs.umass.edu>
 
        * config/h8300/h8300.c (output_a_shift): Remove unused code.

diff --git a/gcc/doc/portability.texi b/gcc/doc/portability.texi
index c3d8e3913d779a603636e9bd500997e4015c30dd..b05698dcfa699df24aedfa101b406000b1879fc2 100644 (file)
--- a/gcc/doc/portability.texi
+++ b/gcc/doc/portability.texi
@@ -1,5 +1,5 @@
 @c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-@c 1999, 2000, 2001 Free Software Foundation, Inc.
+@c 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
 @c This is part of the GCC manual.
 @c For copying conditions, see the file gcc.texi.
 
@@ -8,10 +8,11 @@
 @cindex portability
 @cindex GCC and portability
 
-The main goal of GCC was to make a good, fast compiler for machines in
-the class that the GNU system aims to run on: 32-bit machines that address
-8-bit bytes and have several general registers.  Elegance, theoretical
-power and simplicity are only secondary.
+GCC itself aims to be portable to any machine where @code{int} is at least
+a 32-bit type.  It aims to target machines with a flat (non-segmented) byte
+addressed data address space (the code address space can be separate).
+Target ABIs may have 8, 16, 32 or 64-bit @code{int} type. @code{char}
+can be wider than 8 bits.
 
 GCC gets most of the information about the target machine from a machine
 description which gives an algebraic formula for each of the machine's

diff --git a/gcc/tree.c b/gcc/tree.c
index b2b336b9561acf12c6b1dd5d4d9f9547d8e7b906..f2fc48fd8ce2273bc27450aa67123dbf3279f9c9 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -1363,12 +1363,23 @@ save_expr (expr)
      a constant, it will be more efficient to not make another SAVE_EXPR since
      it will allow better simplification and GCSE will be able to merge the
      computations if they actualy occur.  */
-  for (inner = t;
-       (TREE_CODE_CLASS (TREE_CODE (inner)) == '1'
-       || (TREE_CODE_CLASS (TREE_CODE (inner)) == '2'
-           && TREE_CONSTANT (TREE_OPERAND (inner, 1))));
-       inner = TREE_OPERAND (inner, 0))
-    ;
+  inner = t;
+  while (1)
+    {
+      if (TREE_CODE_CLASS (TREE_CODE (inner)) == '1')
+       inner = TREE_OPERAND (inner, 0);
+      else if (TREE_CODE_CLASS (TREE_CODE (inner)) == '2')
+       {
+         if (TREE_CONSTANT (TREE_OPERAND (inner, 1)))
+           inner = TREE_OPERAND (inner, 0);
+         else if (TREE_CONSTANT (TREE_OPERAND (inner, 0)))
+           inner = TREE_OPERAND (inner, 1);
+         else
+           break;
+       }
+      else
+       break;
+    }
 
   /* If the tree evaluates to a constant, then we don't want to hide that
      fact (i.e. this allows further folding, and direct checks for constants).
@@ -1377,7 +1388,8 @@ save_expr (expr)
      literal node.  */
   if (TREE_CONSTANT (inner)
       || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
-      || TREE_CODE (inner) == SAVE_EXPR || TREE_CODE (inner) == ERROR_MARK)
+      || TREE_CODE (inner) == SAVE_EXPR
+      || TREE_CODE (inner) == ERROR_MARK)
     return t;
 
   /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since