fold() and target-specific macros

[Andrew Haley]

We've been running into a problem where the Java bytecode we generate
from Java source is different on different targets.  Given that
there's only one Java virtual machine, this is odd.  :-)

It's stuff like the code I've attached, which does folding based on
the characteristics of the back end, in particular BITS_PER_WORD.

I'm not sure what to do with this.  Perhaps we should really not be
trying to do this for the Java VM, or maybe we could do something
really simple like disabling target-specific folders when not actually
generating target-specific code.

... ?

Andrew.



	  /* If this was a conversion, and all we did was to move into
	     inside the COND_EXPR, bring it back out.  But leave it if
	     it is a conversion from integer to integer and the
	     result precision is no wider than a word since such a
	     conversion is cheap and may be optimized away by combine,
	     while it couldn't if it were outside the COND_EXPR.  Then return
	     so we don't get into an infinite recursion loop taking the
	     conversion out and then back in.  */

	  if ((code == NOP_EXPR || code == CONVERT_EXPR
	       || code == NON_LVALUE_EXPR)
	      && TREE_CODE (tem) == COND_EXPR
	      && TREE_CODE (TREE_OPERAND (tem, 1)) == code
	      && TREE_CODE (TREE_OPERAND (tem, 2)) == code
	      && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
	      && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
	      && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
		  == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
	      && ! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
		    && (INTEGRAL_TYPE_P
			(TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
		    && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD))
	    tem = build1 (code, type,
			  build3 (COND_EXPR,
				  TREE_TYPE (TREE_OPERAND
					     (TREE_OPERAND (tem, 1), 0)),
				  TREE_OPERAND (tem, 0),
				  TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
				  TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));