This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] PR middle-end/13696: Don't call convert from fold



The following patch is my proposed solution to PR middle-end/13696.
As stated by Mark in bugzilla, the middle-end shouldn't really be
calling "convert", and I can't disagree that constant folding should
be independent of the syntax/semantics permitted by the front-ends.

The solution below is to provide a new function, "fold_convert" in
fold-const.c that can provide all of the type conversions required
and expected by the middle-end.  I was initially naive assuming that
this might be a one-liner "fold (build1 (NOP_EXPR, type, arg))" but
alas type conversion (even when language independent) is slightly
more complicated when using GCC's tree representation.

The rest of the patch is then a mechanical conversion of all
existing uses of "convert" to use the new "fold_convert" instead.


Despite its size, this patch is intended to be as un-invasive as
possible, in the hope that it (and the prerequisite previous clean-up)
can be backported to 3.4 once its been on mainline for a while.  There
are numerous further clean-ups that fallout from this patch, including
exporting fold_convert so that it can be used/reused by tree-ssa, and
eliminating some of the duplication in the language front-ends.
However these follow-ups would affect more files and aren't required
on the 3.4 branch, so they can be posted/appproved/commited later.



The following patch has been tested on i686-pc-linux-gnu with a full
"make bootstrap", all languages except treelang, "make gnatlib_and_tools",
and regression tested with a top-level "make -k check" with no new
failures (including ACATS).


Ok for mainline?



2004-01-24  Roger Sayle  <roger@eyesopen.com>

	PR middle-end/13696
	* fold-const.c (fold_convert): New function to provide type
	conversion to the middle-end without using convert.
	(negate_expr, associate_trees, size_diffop, omit_one_operand,
	operand_equal_for_comparison_p, pedantic_omit_one_operand,
	invert_truthvalue, optimize_bit_field_compare, range_binop,
	decode_field_reference, make_range, build_range_check, unextend,
	fold_truthop, extract_muldiv_1, fold_mathfn_compare,
	fold_binary_op_with_conditional_arg, fold_inf_compare,
	fold_single_bit_test, fold, multiple_of_p): Replace all calls to
	convert with calls to fold_convert.

	* g++.dg/opt/fold1.C: New test case.


Index: fold-const.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/fold-const.c,v
retrieving revision 1.325
diff -c -3 -p -r1.325 fold-const.c
*** fold-const.c	23 Jan 2004 16:52:07 -0000	1.325
--- fold-const.c	24 Jan 2004 23:17:00 -0000
*************** static tree const_binop (enum tree_code,
*** 70,75 ****
--- 70,76 ----
  static hashval_t size_htab_hash (const void *);
  static int size_htab_eq (const void *, const void *);
  static tree fold_convert_const (enum tree_code, tree, tree);
+ static tree fold_convert (tree, tree);
  static enum tree_code invert_tree_comparison (enum tree_code);
  static enum tree_code swap_tree_comparison (enum tree_code);
  static int comparison_to_compcode (enum tree_code);
*************** negate_expr (tree t)
*** 961,967 ****
        tem = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (t)));
        /* Two's complement FP formats, such as c4x, may overflow.  */
        if (! TREE_OVERFLOW (tem) || ! flag_trapping_math)
! 	return convert (type, tem);
        break;

      case COMPLEX_CST:
--- 962,968 ----
        tem = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (t)));
        /* Two's complement FP formats, such as c4x, may overflow.  */
        if (! TREE_OVERFLOW (tem) || ! flag_trapping_math)
! 	return fold_convert (type, tem);
        break;

      case COMPLEX_CST:
*************** negate_expr (tree t)
*** 978,993 ****
        break;

      case NEGATE_EXPR:
!       return convert (type, TREE_OPERAND (t, 0));

      case MINUS_EXPR:
        /* - (A - B) -> B - A  */
        if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
  	  && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
! 	return convert (type,
! 			fold (build (MINUS_EXPR, TREE_TYPE (t),
! 				     TREE_OPERAND (t, 1),
! 				     TREE_OPERAND (t, 0))));
        break;

      case MULT_EXPR:
--- 979,994 ----
        break;

      case NEGATE_EXPR:
!       return fold_convert (type, TREE_OPERAND (t, 0));

      case MINUS_EXPR:
        /* - (A - B) -> B - A  */
        if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
  	  && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
! 	return fold_convert (type,
! 			     fold (build (MINUS_EXPR, TREE_TYPE (t),
! 					  TREE_OPERAND (t, 1),
! 					  TREE_OPERAND (t, 0))));
        break;

      case MULT_EXPR:
*************** negate_expr (tree t)
*** 1001,1016 ****
  	{
  	  tem = TREE_OPERAND (t, 1);
  	  if (negate_expr_p (tem))
! 	    return convert (type,
! 			    fold (build (TREE_CODE (t), TREE_TYPE (t),
! 					 TREE_OPERAND (t, 0),
! 					 negate_expr (tem))));
  	  tem = TREE_OPERAND (t, 0);
  	  if (negate_expr_p (tem))
! 	    return convert (type,
! 			    fold (build (TREE_CODE (t), TREE_TYPE (t),
! 					 negate_expr (tem),
! 					 TREE_OPERAND (t, 1))));
  	}
        break;

--- 1002,1017 ----
  	{
  	  tem = TREE_OPERAND (t, 1);
  	  if (negate_expr_p (tem))
! 	    return fold_convert (type,
! 				 fold (build (TREE_CODE (t), TREE_TYPE (t),
! 					      TREE_OPERAND (t, 0),
! 					      negate_expr (tem))));
  	  tem = TREE_OPERAND (t, 0);
  	  if (negate_expr_p (tem))
! 	    return fold_convert (type,
! 				 fold (build (TREE_CODE (t), TREE_TYPE (t),
! 					      negate_expr (tem),
! 					      TREE_OPERAND (t, 1))));
  	}
        break;

*************** negate_expr (tree t)
*** 1020,1026 ****
  	{
  	  tem = strip_float_extensions (t);
  	  if (tem != t && negate_expr_p (tem))
! 	    return convert (type, negate_expr (tem));
  	}
        break;

--- 1021,1027 ----
  	{
  	  tem = strip_float_extensions (t);
  	  if (tem != t && negate_expr_p (tem))
! 	    return fold_convert (type, negate_expr (tem));
  	}
        break;

*************** negate_expr (tree t)
*** 1042,1048 ****
        break;
      }

!   return convert (type, fold (build1 (NEGATE_EXPR, TREE_TYPE (t), t)));
  }

  /* Split a tree IN into a constant, literal and variable parts that could be
--- 1043,1050 ----
        break;
      }

!   tem = fold (build1 (NEGATE_EXPR, TREE_TYPE (t), t));
!   return fold_convert (type, tem);
  }

  /* Split a tree IN into a constant, literal and variable parts that could be
*************** associate_trees (tree t1, tree t2, enum
*** 1161,1176 ****
        if (code == PLUS_EXPR)
  	{
  	  if (TREE_CODE (t1) == NEGATE_EXPR)
! 	    return build (MINUS_EXPR, type, convert (type, t2),
! 			  convert (type, TREE_OPERAND (t1, 0)));
  	  else if (TREE_CODE (t2) == NEGATE_EXPR)
! 	    return build (MINUS_EXPR, type, convert (type, t1),
! 			  convert (type, TREE_OPERAND (t2, 0)));
  	}
!       return build (code, type, convert (type, t1), convert (type, t2));
      }

!   return fold (build (code, type, convert (type, t1), convert (type, t2)));
  }

  /* Combine two integer constants ARG1 and ARG2 under operation CODE
--- 1163,1180 ----
        if (code == PLUS_EXPR)
  	{
  	  if (TREE_CODE (t1) == NEGATE_EXPR)
! 	    return build (MINUS_EXPR, type, fold_convert (type, t2),
! 			  fold_convert (type, TREE_OPERAND (t1, 0)));
  	  else if (TREE_CODE (t2) == NEGATE_EXPR)
! 	    return build (MINUS_EXPR, type, fold_convert (type, t1),
! 			  fold_convert (type, TREE_OPERAND (t2, 0)));
  	}
!       return build (code, type, fold_convert (type, t1),
! 		    fold_convert (type, t2));
      }

!   return fold (build (code, type, fold_convert (type, t1),
! 		      fold_convert (type, t2)));
  }

  /* Combine two integer constants ARG1 and ARG2 under operation CODE
*************** size_diffop (tree arg0, tree arg1)
*** 1640,1659 ****
       type and subtract.  The hardware will do the right thing with any
       overflow in the subtraction.  */
    if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
!     return size_binop (MINUS_EXPR, convert (ctype, arg0),
! 		       convert (ctype, arg1));

    /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
       Otherwise, subtract the other way, convert to CTYPE (we know that can't
       overflow) and negate (which can't either).  Special-case a result
       of zero while we're here.  */
    if (tree_int_cst_equal (arg0, arg1))
!     return convert (ctype, integer_zero_node);
    else if (tree_int_cst_lt (arg1, arg0))
!     return convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
    else
!     return size_binop (MINUS_EXPR, convert (ctype, integer_zero_node),
! 		       convert (ctype, size_binop (MINUS_EXPR, arg1, arg0)));
  }


--- 1644,1664 ----
       type and subtract.  The hardware will do the right thing with any
       overflow in the subtraction.  */
    if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
!     return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
! 		       fold_convert (ctype, arg1));

    /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
       Otherwise, subtract the other way, convert to CTYPE (we know that can't
       overflow) and negate (which can't either).  Special-case a result
       of zero while we're here.  */
    if (tree_int_cst_equal (arg0, arg1))
!     return fold_convert (ctype, integer_zero_node);
    else if (tree_int_cst_lt (arg1, arg0))
!     return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
    else
!     return size_binop (MINUS_EXPR, fold_convert (ctype, integer_zero_node),
! 		       fold_convert (ctype, size_binop (MINUS_EXPR,
! 							arg1, arg0)));
  }


*************** fold_convert_const (enum tree_code code,
*** 1818,1823 ****
--- 1823,1937 ----
      }
    return NULL_TREE;
  }
+
+ /* Convert expression ARG to type TYPE.  Used by the middle-end for
+    simple conversions in preference to calling the front-end's convert.  */
+
+ static tree
+ fold_convert (tree type, tree arg)
+ {
+   tree orig = TREE_TYPE (arg);
+   tree tem;
+
+   if (type == orig)
+     return arg;
+
+   if (TREE_CODE (arg) == ERROR_MARK
+       || TREE_CODE (type) == ERROR_MARK
+       || TREE_CODE (orig) == ERROR_MARK)
+     return error_mark_node;
+
+   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
+     return fold (build1 (NOP_EXPR, type, arg));
+
+   if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
+     {
+       if (TREE_CODE (arg) == INTEGER_CST)
+ 	{
+ 	  tem = fold_convert_const (NOP_EXPR, type, arg);
+ 	  if (tem != NULL_TREE)
+ 	    return tem;
+ 	}
+       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig))
+         return fold (build1 (NOP_EXPR, type, arg));
+       if (TREE_CODE (orig) == COMPLEX_TYPE)
+ 	{
+ 	  tem = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
+ 	  return fold_convert (type, tem);
+ 	}
+       if (TREE_CODE (orig) == VECTOR_TYPE
+ 	  && GET_MODE_SIZE (TYPE_MODE (type))
+ 	     == GET_MODE_SIZE (TYPE_MODE (orig)))
+ 	return fold (build1 (NOP_EXPR, type, arg));
+     }
+   else if (TREE_CODE (type) == REAL_TYPE)
+     {
+       if (TREE_CODE (arg) == INTEGER_CST)
+ 	{
+ 	  tem = fold_convert_const (FLOAT_EXPR, type, arg);
+ 	  if (tem != NULL_TREE)
+ 	    return tem;
+ 	}
+       else if (TREE_CODE (arg) == REAL_CST)
+ 	{
+ 	  tem = fold_convert_const (NOP_EXPR, type, arg);
+ 	  if (tem != NULL_TREE)
+ 	    return tem;
+ 	}
+
+       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig))
+         return fold (build1 (FLOAT_EXPR, type, arg));
+       if (TREE_CODE (orig) == REAL_TYPE)
+ 	return fold (build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
+ 			     type, arg));
+       if (TREE_CODE (orig) == COMPLEX_TYPE)
+ 	{
+ 	  tem = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
+ 	  return fold_convert (type, tem);
+ 	}
+     }
+   else if (TREE_CODE (type) == COMPLEX_TYPE)
+     {
+       if (INTEGRAL_TYPE_P (orig)
+ 	  || POINTER_TYPE_P (orig)
+ 	  || TREE_CODE (orig) == REAL_TYPE)
+ 	return build (COMPLEX_EXPR, type,
+ 		      fold_convert (TREE_TYPE (type), arg),
+ 		      fold_convert (TREE_TYPE (type), integer_zero_node));
+       if (TREE_CODE (orig) == COMPLEX_TYPE)
+ 	{
+ 	  tree rpart, ipart;
+
+ 	  if (TREE_CODE (arg) == COMPLEX_EXPR)
+ 	    {
+ 	      rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
+ 	      ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
+ 	      return fold (build (COMPLEX_EXPR, type, rpart, ipart));
+ 	    }
+
+ 	  arg = save_expr (arg);
+ 	  rpart = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
+ 	  ipart = fold (build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg));
+ 	  rpart = fold_convert (TREE_TYPE (type), rpart);
+ 	  ipart = fold_convert (TREE_TYPE (type), ipart);
+ 	  return fold (build (COMPLEX_EXPR, type, rpart, ipart));
+ 	}
+     }
+   else if (TREE_CODE (type) == VECTOR_TYPE)
+     {
+       if ((INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig))
+ 	  && GET_MODE_SIZE (TYPE_MODE (type))
+ 	     == GET_MODE_SIZE (TYPE_MODE (orig)))
+ 	return fold (build1 (NOP_EXPR, type, arg));
+       if (TREE_CODE (orig) == VECTOR_TYPE
+ 	  && GET_MODE_SIZE (TYPE_MODE (type))
+ 	     == GET_MODE_SIZE (TYPE_MODE (orig)))
+ 	return fold (build1 (NOP_EXPR, type, arg));
+     }
+   else if (VOID_TYPE_P (type))
+     return fold (build1 (CONVERT_EXPR, type, arg));
+   abort ();
+ }

  /* Return an expr equal to X but certainly not valid as an lvalue.  */

*************** operand_equal_for_comparison_p (tree arg
*** 2252,2261 ****

        /* Make sure shorter operand is extended the right way
  	 to match the longer operand.  */
!       primarg1 = convert ((*lang_hooks.types.signed_or_unsigned_type)
! 			  (unsignedp1, TREE_TYPE (primarg1)), primarg1);

!       if (operand_equal_p (arg0, convert (type, primarg1), 0))
  	return 1;
      }

--- 2366,2375 ----

        /* Make sure shorter operand is extended the right way
  	 to match the longer operand.  */
!       primarg1 = fold_convert ((*lang_hooks.types.signed_or_unsigned_type)
! 			       (unsignedp1, TREE_TYPE (primarg1)), primarg1);

!       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
  	return 1;
      }

*************** eval_subst (tree arg, tree old0, tree ne
*** 2451,2457 ****
  tree
  omit_one_operand (tree type, tree result, tree omitted)
  {
!   tree t = convert (type, result);

    if (TREE_SIDE_EFFECTS (omitted))
      return build (COMPOUND_EXPR, type, omitted, t);
--- 2565,2571 ----
  tree
  omit_one_operand (tree type, tree result, tree omitted)
  {
!   tree t = fold_convert (type, result);

    if (TREE_SIDE_EFFECTS (omitted))
      return build (COMPOUND_EXPR, type, omitted, t);
*************** omit_one_operand (tree type, tree result
*** 2464,2470 ****
  static tree
  pedantic_omit_one_operand (tree type, tree result, tree omitted)
  {
!   tree t = convert (type, result);

    if (TREE_SIDE_EFFECTS (omitted))
      return build (COMPOUND_EXPR, type, omitted, t);
--- 2578,2584 ----
  static tree
  pedantic_omit_one_operand (tree type, tree result, tree omitted)
  {
!   tree t = fold_convert (type, result);

    if (TREE_SIDE_EFFECTS (omitted))
      return build (COMPOUND_EXPR, type, omitted, t);
*************** invert_truthvalue (tree arg)
*** 2504,2510 ****
    switch (code)
      {
      case INTEGER_CST:
!       return convert (type, build_int_2 (integer_zerop (arg), 0));

      case TRUTH_AND_EXPR:
        return build (TRUTH_OR_EXPR, type,
--- 2618,2624 ----
    switch (code)
      {
      case INTEGER_CST:
!       return fold_convert (type, build_int_2 (integer_zerop (arg), 0));

      case TRUTH_AND_EXPR:
        return build (TRUTH_OR_EXPR, type,
*************** invert_truthvalue (tree arg)
*** 2569,2575 ****
      case BIT_AND_EXPR:
        if (!integer_onep (TREE_OPERAND (arg, 1)))
  	break;
!       return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));

      case SAVE_EXPR:
        return build1 (TRUTH_NOT_EXPR, type, arg);
--- 2683,2690 ----
      case BIT_AND_EXPR:
        if (!integer_onep (TREE_OPERAND (arg, 1)))
  	break;
!       return build (EQ_EXPR, type, arg,
! 		    fold_convert (type, integer_zero_node));

      case SAVE_EXPR:
        return build1 (TRUTH_NOT_EXPR, type, arg);
*************** optimize_bit_field_compare (enum tree_co
*** 2743,2749 ****
    mask = build_int_2 (~0, ~0);
    TREE_TYPE (mask) = unsigned_type;
    force_fit_type (mask, 0);
!   mask = convert (unsigned_type, mask);
    mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
    mask = const_binop (RSHIFT_EXPR, mask,
  		      size_int (nbitsize - lbitsize - lbitpos), 0);
--- 2858,2864 ----
    mask = build_int_2 (~0, ~0);
    TREE_TYPE (mask) = unsigned_type;
    force_fit_type (mask, 0);
!   mask = fold_convert (unsigned_type, mask);
    mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
    mask = const_binop (RSHIFT_EXPR, mask,
  		      size_int (nbitsize - lbitsize - lbitpos), 0);
*************** optimize_bit_field_compare (enum tree_co
*** 2773,2799 ****
    if (lunsignedp)
      {
        if (! integer_zerop (const_binop (RSHIFT_EXPR,
! 					convert (unsigned_type, rhs),
  					size_int (lbitsize), 0)))
  	{
  	  warning ("comparison is always %d due to width of bit-field",
  		   code == NE_EXPR);
! 	  return convert (compare_type,
! 			  (code == NE_EXPR
! 			   ? integer_one_node : integer_zero_node));
  	}
      }
    else
      {
!       tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
  			      size_int (lbitsize - 1), 0);
        if (! integer_zerop (tem) && ! integer_all_onesp (tem))
  	{
  	  warning ("comparison is always %d due to width of bit-field",
  		   code == NE_EXPR);
! 	  return convert (compare_type,
! 			  (code == NE_EXPR
! 			   ? integer_one_node : integer_zero_node));
  	}
      }

--- 2888,2914 ----
    if (lunsignedp)
      {
        if (! integer_zerop (const_binop (RSHIFT_EXPR,
! 					fold_convert (unsigned_type, rhs),
  					size_int (lbitsize), 0)))
  	{
  	  warning ("comparison is always %d due to width of bit-field",
  		   code == NE_EXPR);
! 	  return fold_convert (compare_type,
! 			       (code == NE_EXPR
! 				? integer_one_node : integer_zero_node));
  	}
      }
    else
      {
!       tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
  			      size_int (lbitsize - 1), 0);
        if (! integer_zerop (tem) && ! integer_all_onesp (tem))
  	{
  	  warning ("comparison is always %d due to width of bit-field",
  		   code == NE_EXPR);
! 	  return fold_convert (compare_type,
! 			       (code == NE_EXPR
! 				? integer_one_node : integer_zero_node));
  	}
      }

*************** optimize_bit_field_compare (enum tree_co
*** 2801,2807 ****
    if (lbitsize == 1 && ! integer_zerop (rhs))
      {
        code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
!       rhs = convert (type, integer_zero_node);
      }

    /* Make a new bitfield reference, shift the constant over the
--- 2916,2922 ----
    if (lbitsize == 1 && ! integer_zerop (rhs))
      {
        code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
!       rhs = fold_convert (type, integer_zero_node);
      }

    /* Make a new bitfield reference, shift the constant over the
*************** optimize_bit_field_compare (enum tree_co
*** 2816,2822 ****

    rhs = fold (const_binop (BIT_AND_EXPR,
  			   const_binop (LSHIFT_EXPR,
! 					convert (unsigned_type, rhs),
  					size_int (lbitpos), 0),
  			   mask, 0));

--- 2931,2937 ----

    rhs = fold (const_binop (BIT_AND_EXPR,
  			   const_binop (LSHIFT_EXPR,
! 					fold_convert (unsigned_type, rhs),
  					size_int (lbitpos), 0),
  			   mask, 0));

*************** decode_field_reference (tree exp, HOST_W
*** 2910,2916 ****
    /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
    if (and_mask != 0)
      mask = fold (build (BIT_AND_EXPR, unsigned_type,
! 			convert (unsigned_type, and_mask), mask));

    *pmask = mask;
    *pand_mask = and_mask;
--- 3025,3031 ----
    /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
    if (and_mask != 0)
      mask = fold (build (BIT_AND_EXPR, unsigned_type,
! 			fold_convert (unsigned_type, and_mask), mask));

    *pmask = mask;
    *pand_mask = and_mask;
*************** range_binop (enum tree_code code, tree t
*** 3076,3082 ****
    if (arg0 != 0 && arg1 != 0)
      {
        tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
! 			 arg0, convert (TREE_TYPE (arg0), arg1)));
        STRIP_NOPS (tem);
        return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
      }
--- 3191,3197 ----
    if (arg0 != 0 && arg1 != 0)
      {
        tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
! 			 arg0, fold_convert (TREE_TYPE (arg0), arg1)));
        STRIP_NOPS (tem);
        return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
      }
*************** range_binop (enum tree_code code, tree t
*** 3116,3122 ****
        abort ();
      }

!   return convert (type, result ? integer_one_node : integer_zero_node);
  }

  /* Given EXP, a logical expression, set the range it is testing into
--- 3231,3237 ----
        abort ();
      }

!   return fold_convert (type, result ? integer_one_node : integer_zero_node);
  }

  /* Given EXP, a logical expression, set the range it is testing into
*************** make_range (tree exp, int *pin_p, tree *
*** 3140,3146 ****
       the outer loop when we've changed something; otherwise we "break"
       the switch, which will "break" the while.  */

!   in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);

    while (1)
      {
--- 3255,3262 ----
       the outer loop when we've changed something; otherwise we "break"
       the switch, which will "break" the while.  */

!   in_p = 0;
!   low = high = fold_convert (TREE_TYPE (exp), integer_zero_node);

    while (1)
      {
*************** make_range (tree exp, int *pin_p, tree *
*** 3217,3223 ****
  	  if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
  	    {
  	      if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
! 				  1, convert (type, integer_zero_node),
  				  NULL_TREE))
  		break;

--- 3333,3339 ----
  	  if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
  	    {
  	      if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
! 				  1, fold_convert (type, integer_zero_node),
  				  NULL_TREE))
  		break;

*************** make_range (tree exp, int *pin_p, tree *
*** 3231,3237 ****
  		  in_p = ! in_p;
  		  high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
  				      integer_one_node, 0);
! 		  low = convert (type, integer_zero_node);
  		}
  	    }
  	  continue;
--- 3347,3353 ----
  		  in_p = ! in_p;
  		  high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
  				      integer_one_node, 0);
! 		  low = fold_convert (type, integer_zero_node);
  		}
  	    }
  	  continue;
*************** make_range (tree exp, int *pin_p, tree *
*** 3239,3247 ****
  	case NEGATE_EXPR:
  	  /* (-x) IN [a,b] -> x in [-b, -a]  */
  	  n_low = range_binop (MINUS_EXPR, type,
! 			       convert (type, integer_zero_node), 0, high, 1);
  	  n_high = range_binop (MINUS_EXPR, type,
! 				convert (type, integer_zero_node), 0, low, 0);
  	  low = n_low, high = n_high;
  	  exp = arg0;
  	  continue;
--- 3355,3365 ----
  	case NEGATE_EXPR:
  	  /* (-x) IN [a,b] -> x in [-b, -a]  */
  	  n_low = range_binop (MINUS_EXPR, type,
! 			       fold_convert (type, integer_zero_node),
! 			       0, high, 1);
  	  n_high = range_binop (MINUS_EXPR, type,
! 				fold_convert (type, integer_zero_node),
! 				0, low, 0);
  	  low = n_low, high = n_high;
  	  exp = arg0;
  	  continue;
*************** make_range (tree exp, int *pin_p, tree *
*** 3249,3255 ****
  	case BIT_NOT_EXPR:
  	  /* ~ X -> -X - 1  */
  	  exp = build (MINUS_EXPR, type, negate_expr (arg0),
! 		       convert (type, integer_one_node));
  	  continue;

  	case PLUS_EXPR:  case MINUS_EXPR:
--- 3367,3373 ----
  	case BIT_NOT_EXPR:
  	  /* ~ X -> -X - 1  */
  	  exp = build (MINUS_EXPR, type, negate_expr (arg0),
! 		       fold_convert (type, integer_one_node));
  	  continue;

  	case PLUS_EXPR:  case MINUS_EXPR:
*************** make_range (tree exp, int *pin_p, tree *
*** 3305,3314 ****
  	  n_low = low, n_high = high;

  	  if (n_low != 0)
! 	    n_low = convert (type, n_low);

  	  if (n_high != 0)
! 	    n_high = convert (type, n_high);

  	  /* If we're converting from an unsigned to a signed type,
  	     we will be doing the comparison as unsigned.  The tests above
--- 3423,3432 ----
  	  n_low = low, n_high = high;

  	  if (n_low != 0)
! 	    n_low = fold_convert (type, n_low);

  	  if (n_high != 0)
! 	    n_high = fold_convert (type, n_high);

  	  /* If we're converting from an unsigned to a signed type,
  	     we will be doing the comparison as unsigned.  The tests above
*************** make_range (tree exp, int *pin_p, tree *
*** 3331,3338 ****

  	      if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (exp)))
  	        high_positive = fold (build (RSHIFT_EXPR, type,
! 					     convert (type, high_positive),
! 					     convert (type, integer_one_node)));

  	      /* If the low bound is specified, "and" the range with the
  		 range for which the original unsigned value will be
--- 3449,3458 ----

  	      if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (exp)))
  	        high_positive = fold (build (RSHIFT_EXPR, type,
! 					     fold_convert (type,
! 							   high_positive),
! 					     fold_convert (type,
! 							   integer_one_node)));

  	      /* If the low bound is specified, "and" the range with the
  		 range for which the original unsigned value will be
*************** make_range (tree exp, int *pin_p, tree *
*** 3340,3347 ****
  	      if (low != 0)
  		{
  		  if (! merge_ranges (&n_in_p, &n_low, &n_high,
! 				      1, n_low, n_high,
! 				      1, convert (type, integer_zero_node),
  				      high_positive))
  		    break;

--- 3460,3467 ----
  	      if (low != 0)
  		{
  		  if (! merge_ranges (&n_in_p, &n_low, &n_high,
! 				      1, n_low, n_high, 1,
! 				      fold_convert (type, integer_zero_node),
  				      high_positive))
  		    break;

*************** make_range (tree exp, int *pin_p, tree *
*** 3352,3359 ****
  		  /* Otherwise, "or" the range with the range of the input
  		     that will be interpreted as negative.  */
  		  if (! merge_ranges (&n_in_p, &n_low, &n_high,
! 				      0, n_low, n_high,
! 				      1, convert (type, integer_zero_node),
  				      high_positive))
  		    break;

--- 3472,3479 ----
  		  /* Otherwise, "or" the range with the range of the input
  		     that will be interpreted as negative.  */
  		  if (! merge_ranges (&n_in_p, &n_low, &n_high,
! 				      0, n_low, n_high, 1,
! 				      fold_convert (type, integer_zero_node),
  				      high_positive))
  		    break;

*************** build_range_check (tree type, tree exp,
*** 3402,3408 ****
      return invert_truthvalue (value);

    if (low == 0 && high == 0)
!     return convert (type, integer_one_node);

    if (low == 0)
      return fold (build (LE_EXPR, type, exp, high));
--- 3522,3528 ----
      return invert_truthvalue (value);

    if (low == 0 && high == 0)
!     return fold_convert (type, integer_one_node);

    if (low == 0)
      return fold (build (LE_EXPR, type, exp, high));
*************** build_range_check (tree type, tree exp,
*** 3418,3425 ****
        if (! TREE_UNSIGNED (etype))
  	{
  	  etype = (*lang_hooks.types.unsigned_type) (etype);
! 	  high = convert (etype, high);
! 	  exp = convert (etype, exp);
  	}
        return build_range_check (type, exp, 1, 0, high);
      }
--- 3538,3545 ----
        if (! TREE_UNSIGNED (etype))
  	{
  	  etype = (*lang_hooks.types.unsigned_type) (etype);
! 	  high = fold_convert (etype, high);
! 	  exp = fold_convert (etype, exp);
  	}
        return build_range_check (type, exp, 1, 0, high);
      }
*************** build_range_check (tree type, tree exp,
*** 3448,3457 ****
  	  if (TREE_UNSIGNED (etype))
  	    {
  	      etype = (*lang_hooks.types.signed_type) (etype);
! 	      exp = convert (etype, exp);
  	    }
  	  return fold (build (GT_EXPR, type, exp,
! 			      convert (etype, integer_zero_node)));
  	}
      }

--- 3568,3577 ----
  	  if (TREE_UNSIGNED (etype))
  	    {
  	      etype = (*lang_hooks.types.signed_type) (etype);
! 	      exp = fold_convert (etype, exp);
  	    }
  	  return fold (build (GT_EXPR, type, exp,
! 			      fold_convert (etype, integer_zero_node)));
  	}
      }

*************** build_range_check (tree type, tree exp,
*** 3459,3465 ****
        && ! TREE_OVERFLOW (value))
      return build_range_check (type,
  			      fold (build (MINUS_EXPR, etype, exp, low)),
! 			      1, convert (etype, integer_zero_node), value);

    return 0;
  }
--- 3579,3586 ----
        && ! TREE_OVERFLOW (value))
      return build_range_check (type,
  			      fold (build (MINUS_EXPR, etype, exp, low)),
! 			      1, fold_convert (etype, integer_zero_node),
! 			      value);

    return 0;
  }
*************** unextend (tree c, int p, int unsignedp,
*** 3699,3715 ****
       zero or one, and the conversion to a signed type can never overflow.
       We could get an overflow if this conversion is done anywhere else.  */
    if (TREE_UNSIGNED (type))
!     temp = convert ((*lang_hooks.types.signed_type) (type), temp);

    temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
    temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
    if (mask != 0)
!     temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
    /* If necessary, convert the type back to match the type of C.  */
    if (TREE_UNSIGNED (type))
!     temp = convert (type, temp);

!   return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
  }

  /* Find ways of folding logical expressions of LHS and RHS:
--- 3820,3837 ----
       zero or one, and the conversion to a signed type can never overflow.
       We could get an overflow if this conversion is done anywhere else.  */
    if (TREE_UNSIGNED (type))
!     temp = fold_convert ((*lang_hooks.types.signed_type) (type), temp);

    temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
    temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
    if (mask != 0)
!     temp = const_binop (BIT_AND_EXPR, temp,
! 			fold_convert (TREE_TYPE (c), mask), 0);
    /* If necessary, convert the type back to match the type of C.  */
    if (TREE_UNSIGNED (type))
!     temp = fold_convert (type, temp);

!   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
  }

  /* Find ways of folding logical expressions of LHS and RHS:
*************** fold_truthop (enum tree_code code, tree
*** 3827,3835 ****
  	compcode = -1;

        if (compcode == COMPCODE_TRUE)
! 	return convert (truth_type, integer_one_node);
        else if (compcode == COMPCODE_FALSE)
! 	return convert (truth_type, integer_zero_node);
        else if (compcode != -1)
  	return build (compcode_to_comparison (compcode),
  		      truth_type, ll_arg, lr_arg);
--- 3949,3957 ----
  	compcode = -1;

        if (compcode == COMPCODE_TRUE)
! 	return fold_convert (truth_type, integer_one_node);
        else if (compcode == COMPCODE_FALSE)
! 	return fold_convert (truth_type, integer_zero_node);
        else if (compcode != -1)
  	return build (compcode_to_comparison (compcode),
  		      truth_type, ll_arg, lr_arg);
*************** fold_truthop (enum tree_code code, tree
*** 3969,3982 ****
        xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
      }

!   ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
  			 size_int (xll_bitpos), 0);
!   rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
  			 size_int (xrl_bitpos), 0);

    if (l_const)
      {
!       l_const = convert (lntype, l_const);
        l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
        l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
        if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
--- 4091,4104 ----
        xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
      }

!   ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
  			 size_int (xll_bitpos), 0);
!   rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
  			 size_int (xrl_bitpos), 0);

    if (l_const)
      {
!       l_const = fold_convert (lntype, l_const);
        l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
        l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
        if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
*************** fold_truthop (enum tree_code code, tree
*** 3986,3999 ****
  	{
  	  warning ("comparison is always %d", wanted_code == NE_EXPR);

! 	  return convert (truth_type,
! 			  wanted_code == NE_EXPR
! 			  ? integer_one_node : integer_zero_node);
  	}
      }
    if (r_const)
      {
!       r_const = convert (lntype, r_const);
        r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
        r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
        if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
--- 4108,4121 ----
  	{
  	  warning ("comparison is always %d", wanted_code == NE_EXPR);

! 	  return fold_convert (truth_type,
! 			       wanted_code == NE_EXPR
! 			       ? integer_one_node : integer_zero_node);
  	}
      }
    if (r_const)
      {
!       r_const = fold_convert (lntype, r_const);
        r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
        r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
        if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
*************** fold_truthop (enum tree_code code, tree
*** 4003,4011 ****
  	{
  	  warning ("comparison is always %d", wanted_code == NE_EXPR);

! 	  return convert (truth_type,
! 			  wanted_code == NE_EXPR
! 			  ? integer_one_node : integer_zero_node);
  	}
      }

--- 4125,4133 ----
  	{
  	  warning ("comparison is always %d", wanted_code == NE_EXPR);

! 	  return fold_convert (truth_type,
! 			       wanted_code == NE_EXPR
! 			       ? integer_one_node : integer_zero_node);
  	}
      }

*************** fold_truthop (enum tree_code code, tree
*** 4040,4048 ****
  	  xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
  	}

!       lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
  			     size_int (xlr_bitpos), 0);
!       rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
  			     size_int (xrr_bitpos), 0);

        /* Make a mask that corresponds to both fields being compared.
--- 4162,4170 ----
  	  xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
  	}

!       lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
  			     size_int (xlr_bitpos), 0);
!       rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
  			     size_int (xrr_bitpos), 0);

        /* Make a mask that corresponds to both fields being compared.
*************** fold_truthop (enum tree_code code, tree
*** 4097,4110 ****
  	    {
  	      if (lnbitsize > rnbitsize)
  		{
! 		  lhs = convert (rntype, lhs);
! 		  ll_mask = convert (rntype, ll_mask);
  		  type = rntype;
  		}
  	      else if (lnbitsize < rnbitsize)
  		{
! 		  rhs = convert (lntype, rhs);
! 		  lr_mask = convert (lntype, lr_mask);
  		  type = lntype;
  		}
  	    }
--- 4219,4232 ----
  	    {
  	      if (lnbitsize > rnbitsize)
  		{
! 		  lhs = fold_convert (rntype, lhs);
! 		  ll_mask = fold_convert (rntype, ll_mask);
  		  type = rntype;
  		}
  	      else if (lnbitsize < rnbitsize)
  		{
! 		  rhs = fold_convert (lntype, rhs);
! 		  lr_mask = fold_convert (lntype, lr_mask);
  		  type = lntype;
  		}
  	    }
*************** fold_truthop (enum tree_code code, tree
*** 4133,4144 ****
        if (wanted_code == NE_EXPR)
  	{
  	  warning ("`or' of unmatched not-equal tests is always 1");
! 	  return convert (truth_type, integer_one_node);
  	}
        else
  	{
  	  warning ("`and' of mutually exclusive equal-tests is always 0");
! 	  return convert (truth_type, integer_zero_node);
  	}
      }

--- 4255,4266 ----
        if (wanted_code == NE_EXPR)
  	{
  	  warning ("`or' of unmatched not-equal tests is always 1");
! 	  return fold_convert (truth_type, integer_one_node);
  	}
        else
  	{
  	  warning ("`and' of mutually exclusive equal-tests is always 0");
! 	  return fold_convert (truth_type, integer_zero_node);
  	}
      }

*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4323,4329 ****
  	 or (for divide and modulus) if it is a multiple of our constant.  */
        if (code == MULT_EXPR
  	  || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
! 	return const_binop (code, convert (ctype, t), convert (ctype, c), 0);
        break;

      case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
--- 4445,4452 ----
  	 or (for divide and modulus) if it is a multiple of our constant.  */
        if (code == MULT_EXPR
  	  || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
! 	return const_binop (code, fold_convert (ctype, t),
! 			    fold_convert (ctype, c), 0);
        break;

      case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4353,4359 ****
        /* Pass the constant down and see if we can make a simplification.  If
  	 we can, replace this expression with the inner simplification for
  	 possible later conversion to our or some other type.  */
!       if ((t2 = convert (TREE_TYPE (op0), c)) != 0
  	  && TREE_CODE (t2) == INTEGER_CST
  	  && ! TREE_CONSTANT_OVERFLOW (t2)
  	  && (0 != (t1 = extract_muldiv (op0, t2, code,
--- 4476,4482 ----
        /* Pass the constant down and see if we can make a simplification.  If
  	 we can, replace this expression with the inner simplification for
  	 possible later conversion to our or some other type.  */
!       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
  	  && TREE_CODE (t2) == INTEGER_CST
  	  && ! TREE_CONSTANT_OVERFLOW (t2)
  	  && (0 != (t1 = extract_muldiv (op0, t2, code,
*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4364,4370 ****

      case NEGATE_EXPR:  case ABS_EXPR:
        if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
! 	return fold (build1 (tcode, ctype, convert (ctype, t1)));
        break;

      case MIN_EXPR:  case MAX_EXPR:
--- 4487,4493 ----

      case NEGATE_EXPR:  case ABS_EXPR:
        if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
! 	return fold (build1 (tcode, ctype, fold_convert (ctype, t1)));
        break;

      case MIN_EXPR:  case MAX_EXPR:
*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4380,4387 ****
  	  if (tree_int_cst_sgn (c) < 0)
  	    tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);

! 	  return fold (build (tcode, ctype, convert (ctype, t1),
! 			      convert (ctype, t2)));
  	}
        break;

--- 4503,4510 ----
  	  if (tree_int_cst_sgn (c) < 0)
  	    tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);

! 	  return fold (build (tcode, ctype, fold_convert (ctype, t1),
! 			      fold_convert (ctype, t2)));
  	}
        break;

*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4400,4412 ****
  	     so check for it explicitly here.  */
  	  && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
  	  && TREE_INT_CST_HIGH (op1) == 0
! 	  && 0 != (t1 = convert (ctype,
! 				 const_binop (LSHIFT_EXPR, size_one_node,
! 					      op1, 0)))
  	  && ! TREE_OVERFLOW (t1))
  	return extract_muldiv (build (tcode == LSHIFT_EXPR
  				      ? MULT_EXPR : FLOOR_DIV_EXPR,
! 				      ctype, convert (ctype, op0), t1),
  			       c, code, wide_type);
        break;

--- 4523,4536 ----
  	     so check for it explicitly here.  */
  	  && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
  	  && TREE_INT_CST_HIGH (op1) == 0
! 	  && 0 != (t1 = fold_convert (ctype,
! 				      const_binop (LSHIFT_EXPR,
! 						   size_one_node,
! 						   op1, 0)))
  	  && ! TREE_OVERFLOW (t1))
  	return extract_muldiv (build (tcode == LSHIFT_EXPR
  				      ? MULT_EXPR : FLOOR_DIV_EXPR,
! 				      ctype, fold_convert (ctype, op0), t1),
  			       c, code, wide_type);
        break;

*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4423,4430 ****
  		 are divisible by c.  */
  	      || (multiple_of_p (ctype, op0, c)
  	          && multiple_of_p (ctype, op1, c))))
! 	return fold (build (tcode, ctype, convert (ctype, t1),
! 			    convert (ctype, t2)));

        /* If this was a subtraction, negate OP1 and set it to be an addition.
  	 This simplifies the logic below.  */
--- 4547,4554 ----
  		 are divisible by c.  */
  	      || (multiple_of_p (ctype, op0, c)
  	          && multiple_of_p (ctype, op1, c))))
! 	return fold (build (tcode, ctype, fold_convert (ctype, t1),
! 			    fold_convert (ctype, t2)));

        /* If this was a subtraction, negate OP1 and set it to be an addition.
  	 This simplifies the logic below.  */
*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4453,4460 ****
        if (code == MULT_EXPR
  	  || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
  	{
! 	  op1 = const_binop (code, convert (ctype, op1),
! 			     convert (ctype, c), 0);
  	  /* We allow the constant to overflow with wrapping semantics.  */
  	  if (op1 == 0
  	      || (TREE_OVERFLOW (op1) && ! flag_wrapv))
--- 4577,4584 ----
        if (code == MULT_EXPR
  	  || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
  	{
! 	  op1 = const_binop (code, fold_convert (ctype, op1),
! 			     fold_convert (ctype, c), 0);
  	  /* We allow the constant to overflow with wrapping semantics.  */
  	  if (op1 == 0
  	      || (TREE_OVERFLOW (op1) && ! flag_wrapv))
*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4474,4488 ****
        /* If we were able to eliminate our operation from the first side,
  	 apply our operation to the second side and reform the PLUS.  */
        if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
! 	return fold (build (tcode, ctype, convert (ctype, t1), op1));

        /* The last case is if we are a multiply.  In that case, we can
  	 apply the distributive law to commute the multiply and addition
  	 if the multiplication of the constants doesn't overflow.  */
        if (code == MULT_EXPR)
! 	return fold (build (tcode, ctype, fold (build (code, ctype,
! 						       convert (ctype, op0),
! 						       convert (ctype, c))),
  			    op1));

        break;
--- 4598,4613 ----
        /* If we were able to eliminate our operation from the first side,
  	 apply our operation to the second side and reform the PLUS.  */
        if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
! 	return fold (build (tcode, ctype, fold_convert (ctype, t1), op1));

        /* The last case is if we are a multiply.  In that case, we can
  	 apply the distributive law to commute the multiply and addition
  	 if the multiplication of the constants doesn't overflow.  */
        if (code == MULT_EXPR)
! 	return fold (build (tcode, ctype,
! 			    fold (build (code, ctype,
! 					 fold_convert (ctype, op0),
! 					 fold_convert (ctype, c))),
  			    op1));

        break;
*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4505,4526 ****
  	 do something only if the second operand is a constant.  */
        if (same_p
  	  && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
! 	return fold (build (tcode, ctype, convert (ctype, t1),
! 			    convert (ctype, op1)));
        else if (tcode == MULT_EXPR && code == MULT_EXPR
  	       && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
! 	return fold (build (tcode, ctype, convert (ctype, op0),
! 			    convert (ctype, t1)));
        else if (TREE_CODE (op1) != INTEGER_CST)
  	return 0;

        /* If these are the same operation types, we can associate them
  	 assuming no overflow.  */
        if (tcode == code
! 	  && 0 != (t1 = const_binop (MULT_EXPR, convert (ctype, op1),
! 				     convert (ctype, c), 0))
  	  && ! TREE_OVERFLOW (t1))
! 	return fold (build (tcode, ctype, convert (ctype, op0), t1));

        /* If these operations "cancel" each other, we have the main
  	 optimizations of this pass, which occur when either constant is a
--- 4630,4651 ----
  	 do something only if the second operand is a constant.  */
        if (same_p
  	  && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
! 	return fold (build (tcode, ctype, fold_convert (ctype, t1),
! 			    fold_convert (ctype, op1)));
        else if (tcode == MULT_EXPR && code == MULT_EXPR
  	       && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
! 	return fold (build (tcode, ctype, fold_convert (ctype, op0),
! 			    fold_convert (ctype, t1)));
        else if (TREE_CODE (op1) != INTEGER_CST)
  	return 0;

        /* If these are the same operation types, we can associate them
  	 assuming no overflow.  */
        if (tcode == code
! 	  && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
! 				     fold_convert (ctype, c), 0))
  	  && ! TREE_OVERFLOW (t1))
! 	return fold (build (tcode, ctype, fold_convert (ctype, op0), t1));

        /* If these operations "cancel" each other, we have the main
  	 optimizations of this pass, which occur when either constant is a
*************** extract_muldiv_1 (tree t, tree c, enum t
*** 4539,4553 ****
  		  && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
  	{
  	  if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
! 	    return fold (build (tcode, ctype, convert (ctype, op0),
! 				convert (ctype,
! 					 const_binop (TRUNC_DIV_EXPR,
! 						      op1, c, 0))));
  	  else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
! 	    return fold (build (code, ctype, convert (ctype, op0),
! 				convert (ctype,
! 					 const_binop (TRUNC_DIV_EXPR,
! 						      c, op1, 0))));
  	}
        break;

--- 4664,4678 ----
  		  && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
  	{
  	  if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
! 	    return fold (build (tcode, ctype, fold_convert (ctype, op0),
! 				fold_convert (ctype,
! 					      const_binop (TRUNC_DIV_EXPR,
! 							   op1, c, 0))));
  	  else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
! 	    return fold (build (code, ctype, fold_convert (ctype, op0),
! 				fold_convert (ctype,
! 					      const_binop (TRUNC_DIV_EXPR,
! 							   c, op1, 0))));
  	}
        break;

*************** fold_binary_op_with_conditional_arg (enu
*** 4714,4721 ****
      {
        tree testtype = TREE_TYPE (cond);
        test = cond;
!       true_value = convert (testtype, integer_one_node);
!       false_value = convert (testtype, integer_zero_node);
      }

    /* If ARG is complex we want to make sure we only evaluate it once.  Though
--- 4839,4846 ----
      {
        tree testtype = TREE_TYPE (cond);
        test = cond;
!       true_value = fold_convert (testtype, integer_one_node);
!       false_value = fold_convert (testtype, integer_zero_node);
      }

    /* If ARG is complex we want to make sure we only evaluate it once.  Though
*************** fold_binary_op_with_conditional_arg (enu
*** 4768,4777 ****
       of ARG is not enough to decide here.  */
    if (save)
      return build (COMPOUND_EXPR, type,
! 		  convert (void_type_node, arg),
  		  strip_compound_expr (test, arg));
    else
!     return convert (type, test);
  }


--- 4893,4902 ----
       of ARG is not enough to decide here.  */
    if (save)
      return build (COMPOUND_EXPR, type,
! 		  fold_convert (void_type_node, arg),
  		  strip_compound_expr (test, arg));
    else
!     return fold_convert (type, test);
  }


*************** fold_mathfn_compare (enum built_in_funct
*** 4843,4856 ****
  	  /* sqrt(x) < y is always false, if y is negative.  */
  	  if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
  	    return omit_one_operand (type,
! 				     convert (type, integer_zero_node),
  				     arg);

  	  /* sqrt(x) > y is always true, if y is negative and we
  	     don't care about NaNs, i.e. negative values of x.  */
  	  if (code == NE_EXPR || !HONOR_NANS (mode))
  	    return omit_one_operand (type,
! 				     convert (type, integer_one_node),
  				     arg);

  	  /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
--- 4968,4981 ----
  	  /* sqrt(x) < y is always false, if y is negative.  */
  	  if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
  	    return omit_one_operand (type,
! 				     fold_convert (type, integer_zero_node),
  				     arg);

  	  /* sqrt(x) > y is always true, if y is negative and we
  	     don't care about NaNs, i.e. negative values of x.  */
  	  if (code == NE_EXPR || !HONOR_NANS (mode))
  	    return omit_one_operand (type,
! 				     fold_convert (type, integer_one_node),
  				     arg);

  	  /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
*************** fold_mathfn_compare (enum built_in_funct
*** 4874,4880 ****
  	      /* sqrt(x) > y is always false, when y is very large
  		 and we don't care about infinities.  */
  	      return omit_one_operand (type,
! 				       convert (type, integer_zero_node),
  				       arg);
  	    }

--- 4999,5005 ----
  	      /* sqrt(x) > y is always false, when y is very large
  		 and we don't care about infinities.  */
  	      return omit_one_operand (type,
! 				       fold_convert (type, integer_zero_node),
  				       arg);
  	    }

*************** fold_mathfn_compare (enum built_in_funct
*** 4895,4901 ****
  		 value and we don't care about NaNs or Infinities.  */
  	      if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
  		return omit_one_operand (type,
! 					 convert (type, integer_one_node),
  					 arg);

  	      /* sqrt(x) < y is x != +Inf when y is very large and we
--- 5020,5026 ----
  		 value and we don't care about NaNs or Infinities.  */
  	      if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
  		return omit_one_operand (type,
! 					 fold_convert (type, integer_one_node),
  					 arg);

  	      /* sqrt(x) < y is x != +Inf when y is very large and we
*************** fold_inf_compare (enum tree_code code, t
*** 4981,4994 ****
        if (HONOR_SNANS (mode))
          return NULL_TREE;
        return omit_one_operand (type,
! 			       convert (type, integer_zero_node),
  			       arg0);

      case LE_EXPR:
        /* x <= +Inf is always true, if we don't case about NaNs.  */
        if (! HONOR_NANS (mode))
  	return omit_one_operand (type,
! 				 convert (type, integer_one_node),
  				 arg0);

        /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
--- 5106,5119 ----
        if (HONOR_SNANS (mode))
          return NULL_TREE;
        return omit_one_operand (type,
! 			       fold_convert (type, integer_zero_node),
  			       arg0);

      case LE_EXPR:
        /* x <= +Inf is always true, if we don't case about NaNs.  */
        if (! HONOR_NANS (mode))
  	return omit_one_operand (type,
! 				 fold_convert (type, integer_one_node),
  				 arg0);

        /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
*************** fold_single_bit_test (enum tree_code cod
*** 5075,5082 ****
  	{
  	  tree stype = (*lang_hooks.types.signed_type) (TREE_TYPE (arg00));
  	  return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, result_type,
! 			      convert (stype, arg00),
! 			      convert (stype, integer_zero_node)));
  	}

        /* At this point, we know that arg0 is not testing the sign bit.  */
--- 5200,5207 ----
  	{
  	  tree stype = (*lang_hooks.types.signed_type) (TREE_TYPE (arg00));
  	  return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, result_type,
! 			      fold_convert (stype, arg00),
! 			      fold_convert (stype, integer_zero_node)));
  	}

        /* At this point, we know that arg0 is not testing the sign bit.  */
*************** fold_single_bit_test (enum tree_code cod
*** 5112,5118 ****
        signed_type = (*lang_hooks.types.type_for_mode) (operand_mode, 0);
        unsigned_type = (*lang_hooks.types.type_for_mode) (operand_mode, 1);
        intermediate_type = ops_unsigned ? unsigned_type : signed_type;
!       inner = convert (intermediate_type, inner);

        if (bitnum != 0)
  	inner = build (RSHIFT_EXPR, intermediate_type,
--- 5237,5243 ----
        signed_type = (*lang_hooks.types.type_for_mode) (operand_mode, 0);
        unsigned_type = (*lang_hooks.types.type_for_mode) (operand_mode, 1);
        intermediate_type = ops_unsigned ? unsigned_type : signed_type;
!       inner = fold_convert (intermediate_type, inner);

        if (bitnum != 0)
  	inner = build (RSHIFT_EXPR, intermediate_type,
*************** fold_single_bit_test (enum tree_code cod
*** 5127,5133 ****
  		     inner, integer_one_node);

        /* Make sure to return the proper type.  */
!       inner = convert (result_type, inner);

        return inner;
      }
--- 5252,5258 ----
  		     inner, integer_one_node);

        /* Make sure to return the proper type.  */
!       inner = fold_convert (result_type, inner);

        return inner;
      }
*************** fold (tree expr)
*** 5493,5499 ****
  	  if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (final_type)
  	      && ((inter_int && final_int) || (inter_float && final_float))
  	      && inter_prec >= final_prec)
! 	    return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));

  	  /* Likewise, if the intermediate and final types are either both
  	     float or both integer, we don't need the middle conversion if
--- 5618,5625 ----
  	  if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (final_type)
  	      && ((inter_int && final_int) || (inter_float && final_float))
  	      && inter_prec >= final_prec)
! 	    return fold_convert (final_type,
! 				 TREE_OPERAND (TREE_OPERAND (t, 0), 0));

  	  /* Likewise, if the intermediate and final types are either both
  	     float or both integer, we don't need the middle conversion if
*************** fold (tree expr)
*** 5508,5521 ****
  	      && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
  		    && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
  	      && ! final_ptr)
! 	    return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));

  	  /* If we have a sign-extension of a zero-extended value, we can
  	     replace that by a single zero-extension.  */
  	  if (inside_int && inter_int && final_int
  	      && inside_prec < inter_prec && inter_prec < final_prec
  	      && inside_unsignedp && !inter_unsignedp)
! 	    return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));

  	  /* Two conversions in a row are not needed unless:
  	     - some conversion is floating-point (overstrict for now), or
--- 5634,5649 ----
  	      && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
  		    && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
  	      && ! final_ptr)
! 	    return fold_convert (final_type,
! 				 TREE_OPERAND (TREE_OPERAND (t, 0), 0));

  	  /* If we have a sign-extension of a zero-extended value, we can
  	     replace that by a single zero-extension.  */
  	  if (inside_int && inter_int && final_int
  	      && inside_prec < inter_prec && inter_prec < final_prec
  	      && inside_unsignedp && !inter_unsignedp)
! 	    return fold_convert (final_type,
! 				 TREE_OPERAND (TREE_OPERAND (t, 0), 0));

  	  /* Two conversions in a row are not needed unless:
  	     - some conversion is floating-point (overstrict for now), or
*************** fold (tree expr)
*** 5539,5545 ****
  	      && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
  		    && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
  	      && ! final_ptr)
! 	    return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
  	}

        if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
--- 5667,5674 ----
  	      && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
  		    && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
  	      && ! final_ptr)
! 	    return fold_convert (final_type,
! 				 TREE_OPERAND (TREE_OPERAND (t, 0), 0));
  	}

        if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
*************** fold (tree expr)
*** 5592,5606 ****
  		      == ZERO_EXTEND))
  		{
  		  tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
! 		  and0 = convert (uns, and0);
! 		  and1 = convert (uns, and1);
  		}
  #endif
  	    }
  	  if (change)
  	    return fold (build (BIT_AND_EXPR, TREE_TYPE (t),
! 				convert (TREE_TYPE (t), and0),
! 				convert (TREE_TYPE (t), and1)));
  	}

        tem = fold_convert_const (code, TREE_TYPE (t), arg0);
--- 5721,5735 ----
  		      == ZERO_EXTEND))
  		{
  		  tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
! 		  and0 = fold_convert (uns, and0);
! 		  and1 = fold_convert (uns, and1);
  		}
  #endif
  	    }
  	  if (change)
  	    return fold (build (BIT_AND_EXPR, TREE_TYPE (t),
! 				fold_convert (TREE_TYPE (t), and0),
! 				fold_convert (TREE_TYPE (t), and1)));
  	}

        tem = fold_convert_const (code, TREE_TYPE (t), arg0);
*************** fold (tree expr)
*** 5681,5688 ****
  	{
  	  tree targ0 = strip_float_extensions (arg0);
  	  if (targ0 != arg0)
! 	    return convert (type, fold (build1 (ABS_EXPR, TREE_TYPE (targ0),
! 						targ0)));
  	}
        else if (tree_expr_nonnegative_p (arg0))
  	return arg0;
--- 5810,5818 ----
  	{
  	  tree targ0 = strip_float_extensions (arg0);
  	  if (targ0 != arg0)
! 	    return fold_convert (type, fold (build1 (ABS_EXPR,
! 						     TREE_TYPE (targ0),
! 						     targ0)));
  	}
        else if (tree_expr_nonnegative_p (arg0))
  	return arg0;
*************** fold (tree expr)
*** 5690,5696 ****

      case CONJ_EXPR:
        if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
! 	return convert (type, arg0);
        else if (TREE_CODE (arg0) == COMPLEX_EXPR)
  	return build (COMPLEX_EXPR, type,
  		      TREE_OPERAND (arg0, 0),
--- 5820,5826 ----

      case CONJ_EXPR:
        if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
! 	return fold_convert (type, arg0);
        else if (TREE_CODE (arg0) == COMPLEX_EXPR)
  	return build (COMPLEX_EXPR, type,
  		      TREE_OPERAND (arg0, 0),
*************** fold (tree expr)
*** 5732,5738 ****
        else if (! FLOAT_TYPE_P (type))
  	{
  	  if (integer_zerop (arg1))
! 	    return non_lvalue (convert (type, arg0));

  	  /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
  	     with a constant, and the two constants have no bits in common,
--- 5862,5868 ----
        else if (! FLOAT_TYPE_P (type))
  	{
  	  if (integer_zerop (arg1))
! 	    return non_lvalue (fold_convert (type, arg0));

  	  /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
  	     with a constant, and the two constants have no bits in common,
*************** fold (tree expr)
*** 5773,5788 ****
  		  && TREE_CODE (parg1) != MULT_EXPR)
  		return fold (build (PLUS_EXPR, type,
  				    fold (build (PLUS_EXPR, type,
! 						 convert (type, parg0),
! 						 convert (type, marg))),
! 				    convert (type, parg1)));
  	      if (TREE_CODE (parg0) != MULT_EXPR
  		  && TREE_CODE (parg1) == MULT_EXPR)
  		return fold (build (PLUS_EXPR, type,
  				    fold (build (PLUS_EXPR, type,
! 						 convert (type, parg1),
! 						 convert (type, marg))),
! 				    convert (type, parg0)));
  	    }

  	  if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
--- 5903,5918 ----
  		  && TREE_CODE (parg1) != MULT_EXPR)
  		return fold (build (PLUS_EXPR, type,
  				    fold (build (PLUS_EXPR, type,
! 						 fold_convert (type, parg0),
! 						 fold_convert (type, marg))),
! 				    fold_convert (type, parg1)));
  	      if (TREE_CODE (parg0) != MULT_EXPR
  		  && TREE_CODE (parg1) == MULT_EXPR)
  		return fold (build (PLUS_EXPR, type,
  				    fold (build (PLUS_EXPR, type,
! 						 fold_convert (type, parg1),
! 						 fold_convert (type, marg))),
! 				    fold_convert (type, parg0)));
  	    }

  	  if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
*************** fold (tree expr)
*** 5850,5860 ****
  	{
  	  /* See if ARG1 is zero and X + ARG1 reduces to X.  */
  	  if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
! 	    return non_lvalue (convert (type, arg0));

  	  /* Likewise if the operands are reversed.  */
  	  if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
! 	    return non_lvalue (convert (type, arg1));

  	  /* Convert x+x into x*2.0.  */
  	  if (operand_equal_p (arg0, arg1, 0)
--- 5980,5990 ----
  	{
  	  /* See if ARG1 is zero and X + ARG1 reduces to X.  */
  	  if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
! 	    return non_lvalue (fold_convert (type, arg0));

  	  /* Likewise if the operands are reversed.  */
  	  if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
! 	    return non_lvalue (fold_convert (type, arg1));

  	  /* Convert x+x into x*2.0.  */
  	  if (operand_equal_p (arg0, arg1, 0)
*************** fold (tree expr)
*** 6047,6065 ****
  	      if (minus_lit0)
  		{
  		  if (con0 == 0)
! 		    return convert (type, associate_trees (var0, minus_lit0,
! 							   MINUS_EXPR, type));
  		  else
  		    {
  		      con0 = associate_trees (con0, minus_lit0,
  					      MINUS_EXPR, type);
! 		      return convert (type, associate_trees (var0, con0,
! 							     PLUS_EXPR, type));
  		    }
  		}

  	      con0 = associate_trees (con0, lit0, code, type);
! 	      return convert (type, associate_trees (var0, con0, code, type));
  	    }
  	}

--- 6177,6198 ----
  	      if (minus_lit0)
  		{
  		  if (con0 == 0)
! 		    return fold_convert (type,
! 					 associate_trees (var0, minus_lit0,
! 							  MINUS_EXPR, type));
  		  else
  		    {
  		      con0 = associate_trees (con0, minus_lit0,
  					      MINUS_EXPR, type);
! 		      return fold_convert (type,
! 					   associate_trees (var0, con0,
! 							    PLUS_EXPR, type));
  		    }
  		}

  	      con0 = associate_trees (con0, lit0, code, type);
! 	      return fold_convert (type, associate_trees (var0, con0,
! 							  code, type));
  	    }
  	}

*************** fold (tree expr)
*** 6071,6077 ****
  	  /* The return value should always have
  	     the same type as the original expression.  */
  	  if (TREE_TYPE (t1) != TREE_TYPE (t))
! 	    t1 = convert (TREE_TYPE (t), t1);

  	  return t1;
  	}
--- 6204,6210 ----
  	  /* The return value should always have
  	     the same type as the original expression.  */
  	  if (TREE_TYPE (t1) != TREE_TYPE (t))
! 	    t1 = fold_convert (TREE_TYPE (t), t1);

  	  return t1;
  	}
*************** fold (tree expr)
*** 6093,6101 ****
        if (! FLOAT_TYPE_P (type))
  	{
  	  if (! wins && integer_zerop (arg0))
! 	    return negate_expr (convert (type, arg1));
  	  if (integer_zerop (arg1))
! 	    return non_lvalue (convert (type, arg0));

  	  /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
  	     about the case where C is a constant, just try one of the
--- 6226,6234 ----
        if (! FLOAT_TYPE_P (type))
  	{
  	  if (! wins && integer_zerop (arg0))
! 	    return negate_expr (fold_convert (type, arg1));
  	  if (integer_zerop (arg1))
! 	    return non_lvalue (fold_convert (type, arg0));

  	  /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
  	     about the case where C is a constant, just try one of the
*************** fold (tree expr)
*** 6148,6160 ****

        /* See if ARG1 is zero and X - ARG1 reduces to X.  */
        else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
! 	return non_lvalue (convert (type, arg0));

        /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
  	 ARG0 is zero and X + ARG0 reduces to X, since that would mean
  	 (-ARG1 + ARG0) reduces to -ARG1.  */
        else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
! 	return negate_expr (convert (type, arg1));

        /* Fold &x - &x.  This can happen from &x.foo - &x.
  	 This is unsafe for certain floats even in non-IEEE formats.
--- 6281,6293 ----

        /* See if ARG1 is zero and X - ARG1 reduces to X.  */
        else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
! 	return non_lvalue (fold_convert (type, arg0));

        /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
  	 ARG0 is zero and X + ARG0 reduces to X, since that would mean
  	 (-ARG1 + ARG0) reduces to -ARG1.  */
        else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
! 	return negate_expr (fold_convert (type, arg1));

        /* Fold &x - &x.  This can happen from &x.foo - &x.
  	 This is unsafe for certain floats even in non-IEEE formats.
*************** fold (tree expr)
*** 6164,6170 ****

        if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
  	  && operand_equal_p (arg0, arg1, 0))
! 	return convert (type, integer_zero_node);

        goto associate;

--- 6297,6303 ----

        if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
  	  && operand_equal_p (arg0, arg1, 0))
! 	return fold_convert (type, integer_zero_node);

        goto associate;

*************** fold (tree expr)
*** 6184,6190 ****
  	  if (integer_zerop (arg1))
  	    return omit_one_operand (type, arg1, arg0);
  	  if (integer_onep (arg1))
! 	    return non_lvalue (convert (type, arg0));

  	  /* (a * (1 << b)) is (a << b)  */
  	  if (TREE_CODE (arg1) == LSHIFT_EXPR
--- 6317,6323 ----
  	  if (integer_zerop (arg1))
  	    return omit_one_operand (type, arg1, arg0);
  	  if (integer_onep (arg1))
! 	    return non_lvalue (fold_convert (type, arg0));

  	  /* (a * (1 << b)) is (a << b)  */
  	  if (TREE_CODE (arg1) == LSHIFT_EXPR
*************** fold (tree expr)
*** 6198,6206 ****

  	  if (TREE_CODE (arg1) == INTEGER_CST
  	      && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0),
! 					     convert (type, arg1),
  					     code, NULL_TREE)))
! 	    return convert (type, tem);

  	}
        else
--- 6331,6339 ----

  	  if (TREE_CODE (arg1) == INTEGER_CST
  	      && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0),
! 					     fold_convert (type, arg1),
  					     code, NULL_TREE)))
! 	    return fold_convert (type, tem);

  	}
        else
*************** fold (tree expr)
*** 6216,6222 ****
  	  /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
  	  if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
  	      && real_onep (arg1))
! 	    return non_lvalue (convert (type, arg0));

  	  /* Transform x * -1.0 into -x.  */
  	  if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
--- 6349,6355 ----
  	  /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
  	  if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
  	      && real_onep (arg1))
! 	    return non_lvalue (fold_convert (type, arg0));

  	  /* Transform x * -1.0 into -x.  */
  	  if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
*************** fold (tree expr)
*** 6437,6443 ****
        if (integer_all_onesp (arg1))
  	return omit_one_operand (type, arg1, arg0);
        if (integer_zerop (arg1))
! 	return non_lvalue (convert (type, arg0));
        t1 = distribute_bit_expr (code, type, arg0, arg1);
        if (t1 != NULL_TREE)
  	return t1;
--- 6570,6576 ----
        if (integer_all_onesp (arg1))
  	return omit_one_operand (type, arg1, arg0);
        if (integer_zerop (arg1))
! 	return non_lvalue (fold_convert (type, arg0));
        t1 = distribute_bit_expr (code, type, arg0, arg1);
        if (t1 != NULL_TREE)
  	return t1;
*************** fold (tree expr)
*** 6463,6469 ****

      case BIT_XOR_EXPR:
        if (integer_zerop (arg1))
! 	return non_lvalue (convert (type, arg0));
        if (integer_all_onesp (arg1))
  	return fold (build1 (BIT_NOT_EXPR, type, arg0));

--- 6596,6602 ----

      case BIT_XOR_EXPR:
        if (integer_zerop (arg1))
! 	return non_lvalue (fold_convert (type, arg0));
        if (integer_all_onesp (arg1))
  	return fold (build1 (BIT_NOT_EXPR, type, arg0));

*************** fold (tree expr)
*** 6489,6495 ****

      case BIT_AND_EXPR:
        if (integer_all_onesp (arg1))
! 	return non_lvalue (convert (type, arg0));
        if (integer_zerop (arg1))
  	return omit_one_operand (type, arg1, arg0);
        t1 = distribute_bit_expr (code, type, arg0, arg1);
--- 6622,6628 ----

      case BIT_AND_EXPR:
        if (integer_all_onesp (arg1))
! 	return non_lvalue (fold_convert (type, arg0));
        if (integer_zerop (arg1))
  	return omit_one_operand (type, arg1, arg0);
        t1 = distribute_bit_expr (code, type, arg0, arg1);
*************** fold (tree expr)
*** 6505,6511 ****
  	  if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
  	      && (~TREE_INT_CST_LOW (arg1)
  		  & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
! 	    return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
  	}

        /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
--- 6638,6644 ----
  	  if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
  	      && (~TREE_INT_CST_LOW (arg1)
  		  & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
! 	    return fold_convert (type, TREE_OPERAND (arg0, 0));
  	}

        /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
*************** fold (tree expr)
*** 6546,6557 ****
        /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
        if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
  	  && real_onep (arg1))
! 	return non_lvalue (convert (type, arg0));

        /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
        if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
  	  && real_minus_onep (arg1))
! 	return non_lvalue (convert (type, negate_expr (arg0)));

        /* If ARG1 is a constant, we can convert this to a multiply by the
  	 reciprocal.  This does not have the same rounding properties,
--- 6679,6690 ----
        /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
        if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
  	  && real_onep (arg1))
! 	return non_lvalue (fold_convert (type, arg0));

        /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
        if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
  	  && real_minus_onep (arg1))
! 	return non_lvalue (fold_convert (type, negate_expr (arg0)));

        /* If ARG1 is a constant, we can convert this to a multiply by the
  	 reciprocal.  This does not have the same rounding properties,
*************** fold (tree expr)
*** 6733,6739 ****
      case CEIL_DIV_EXPR:
      case EXACT_DIV_EXPR:
        if (integer_onep (arg1))
! 	return non_lvalue (convert (type, arg0));
        if (integer_zerop (arg1))
  	return t;

--- 6866,6872 ----
      case CEIL_DIV_EXPR:
      case EXACT_DIV_EXPR:
        if (integer_onep (arg1))
! 	return non_lvalue (fold_convert (type, arg0));
        if (integer_zerop (arg1))
  	return t;

*************** fold (tree expr)
*** 6750,6756 ****
        if (TREE_CODE (arg1) == INTEGER_CST
  	  && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
  					 code, NULL_TREE)))
! 	return convert (type, tem);

        goto binary;

--- 6883,6889 ----
        if (TREE_CODE (arg1) == INTEGER_CST
  	  && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
  					 code, NULL_TREE)))
! 	return fold_convert (type, tem);

        goto binary;

*************** fold (tree expr)
*** 6766,6772 ****
        if (TREE_CODE (arg1) == INTEGER_CST
  	  && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
  					 code, NULL_TREE)))
! 	return convert (type, tem);

        goto binary;

--- 6899,6905 ----
        if (TREE_CODE (arg1) == INTEGER_CST
  	  && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
  					 code, NULL_TREE)))
! 	return fold_convert (type, tem);

        goto binary;

*************** fold (tree expr)
*** 6785,6791 ****
      case LSHIFT_EXPR:
      shift:
        if (integer_zerop (arg1))
! 	return non_lvalue (convert (type, arg0));
        if (integer_zerop (arg0))
  	return omit_one_operand (type, arg0, arg1);

--- 6918,6924 ----
      case LSHIFT_EXPR:
      shift:
        if (integer_zerop (arg1))
! 	return non_lvalue (fold_convert (type, arg0));
        if (integer_zerop (arg0))
  	return omit_one_operand (type, arg0, arg1);

*************** fold (tree expr)
*** 6798,6804 ****
        if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
  	{
  	  tree tem = build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0);
! 	  tem = convert (TREE_TYPE (arg1), tem);
  	  tem = const_binop (MINUS_EXPR, tem, arg1, 0);
  	  return fold (build (RROTATE_EXPR, type, arg0, tem));
  	}
--- 6931,6937 ----
        if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
  	{
  	  tree tem = build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0);
! 	  tem = fold_convert (TREE_TYPE (arg1), tem);
  	  tem = const_binop (MINUS_EXPR, tem, arg1, 0);
  	  return fold (build (RROTATE_EXPR, type, arg0, tem));
  	}
*************** fold (tree expr)
*** 6862,6868 ****
  	    return tem;
  	  return t;
  	}
!       return convert (type, tem);

      case TRUTH_ANDIF_EXPR:
        /* Note that the operands of this must be ints
--- 6995,7001 ----
  	    return tem;
  	  return t;
  	}
!       return fold_convert (type, tem);

      case TRUTH_ANDIF_EXPR:
        /* Note that the operands of this must be ints
*************** fold (tree expr)
*** 6870,6884 ****
  	 ("true" is a fixed value perhaps depending on the language.)  */
        /* If first arg is constant zero, return it.  */
        if (integer_zerop (arg0))
! 	return convert (type, arg0);
      case TRUTH_AND_EXPR:
        /* If either arg is constant true, drop it.  */
        if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
! 	return non_lvalue (convert (type, arg1));
        if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
  	  /* Preserve sequence points.  */
  	  && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
! 	return non_lvalue (convert (type, arg0));
        /* If second arg is constant zero, result is zero, but first arg
  	 must be evaluated.  */
        if (integer_zerop (arg1))
--- 7003,7017 ----
  	 ("true" is a fixed value perhaps depending on the language.)  */
        /* If first arg is constant zero, return it.  */
        if (integer_zerop (arg0))
! 	return fold_convert (type, arg0);
      case TRUTH_AND_EXPR:
        /* If either arg is constant true, drop it.  */
        if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
! 	return non_lvalue (fold_convert (type, arg1));
        if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
  	  /* Preserve sequence points.  */
  	  && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
! 	return non_lvalue (fold_convert (type, arg0));
        /* If second arg is constant zero, result is zero, but first arg
  	 must be evaluated.  */
        if (integer_zerop (arg1))
*************** fold (tree expr)
*** 6958,6972 ****
  	 ("true" is a fixed value perhaps depending on the language.)  */
        /* If first arg is constant true, return it.  */
        if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
! 	return convert (type, arg0);
      case TRUTH_OR_EXPR:
        /* If either arg is constant zero, drop it.  */
        if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
! 	return non_lvalue (convert (type, arg1));
        if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
  	  /* Preserve sequence points.  */
  	  && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
! 	return non_lvalue (convert (type, arg0));
        /* If second arg is constant true, result is true, but we must
  	 evaluate first arg.  */
        if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
--- 7091,7105 ----
  	 ("true" is a fixed value perhaps depending on the language.)  */
        /* If first arg is constant true, return it.  */
        if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
! 	return fold_convert (type, arg0);
      case TRUTH_OR_EXPR:
        /* If either arg is constant zero, drop it.  */
        if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
! 	return non_lvalue (fold_convert (type, arg1));
        if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
  	  /* Preserve sequence points.  */
  	  && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
! 	return non_lvalue (fold_convert (type, arg0));
        /* If second arg is constant true, result is true, but we must
  	 evaluate first arg.  */
        if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
*************** fold (tree expr)
*** 6980,6993 ****
      case TRUTH_XOR_EXPR:
        /* If either arg is constant zero, drop it.  */
        if (integer_zerop (arg0))
! 	return non_lvalue (convert (type, arg1));
        if (integer_zerop (arg1))
! 	return non_lvalue (convert (type, arg0));
        /* If either arg is constant true, this is a logical inversion.  */
        if (integer_onep (arg0))
! 	return non_lvalue (convert (type, invert_truthvalue (arg1)));
        if (integer_onep (arg1))
! 	return non_lvalue (convert (type, invert_truthvalue (arg0)));
        return t;

      case EQ_EXPR:
--- 7113,7126 ----
      case TRUTH_XOR_EXPR:
        /* If either arg is constant zero, drop it.  */
        if (integer_zerop (arg0))
! 	return non_lvalue (fold_convert (type, arg1));
        if (integer_zerop (arg1))
! 	return non_lvalue (fold_convert (type, arg0));
        /* If either arg is constant true, this is a logical inversion.  */
        if (integer_onep (arg0))
! 	return non_lvalue (fold_convert (type, invert_truthvalue (arg1)));
        if (integer_onep (arg1))
! 	return non_lvalue (fold_convert (type, invert_truthvalue (arg0)));
        return t;

      case EQ_EXPR:
*************** fold (tree expr)
*** 7011,7018 ****

  	  /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
  	  if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
! 	    return fold (build (code, type, convert (newtype, targ0),
! 				convert (newtype, targ1)));

  	  /* (-a) CMP (-b) -> b CMP a  */
  	  if (TREE_CODE (arg0) == NEGATE_EXPR
--- 7144,7151 ----

  	  /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
  	  if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
! 	    return fold (build (code, type, fold_convert (newtype, targ0),
! 				fold_convert (newtype, targ1)));

  	  /* (-a) CMP (-b) -> b CMP a  */
  	  if (TREE_CODE (arg0) == NEGATE_EXPR
*************** fold (tree expr)
*** 7044,7050 ****
  		&& ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
  	      {
  		t = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
! 		return omit_one_operand (type, convert (type, t), arg0);
  	      }

  	    /* Fold comparisons against infinity.  */
--- 7177,7183 ----
  		&& ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
  	      {
  		t = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
! 		return omit_one_operand (type, fold_convert (type, t), arg0);
  	      }

  	    /* Fold comparisons against infinity.  */
*************** fold (tree expr)
*** 7172,7179 ****
  					size_int (precision - size), 0);
  		    newconst = fold (build (BIT_AND_EXPR,
  					    TREE_TYPE (varop), newconst,
! 					    convert (TREE_TYPE (varop),
! 						     mask)));
  		  }

  		t = build (code, type,
--- 7305,7312 ----
  					size_int (precision - size), 0);
  		    newconst = fold (build (BIT_AND_EXPR,
  					    TREE_TYPE (varop), newconst,
! 					    fold_convert (TREE_TYPE (varop),
! 							  mask)));
  		  }

  		t = build (code, type,
*************** fold (tree expr)
*** 7233,7240 ****
  					size_int (precision - size), 0);
  		    newconst = fold (build (BIT_AND_EXPR,
  					    TREE_TYPE (varop), newconst,
! 					    convert (TREE_TYPE (varop),
! 						     mask)));
  		  }

  		t = build (code, type,
--- 7366,7373 ----
  					size_int (precision - size), 0);
  		    newconst = fold (build (BIT_AND_EXPR,
  					    TREE_TYPE (varop), newconst,
! 					    fold_convert (TREE_TYPE (varop),
! 							  mask)));
  		  }

  		t = build (code, type,
*************** fold (tree expr)
*** 7300,7313 ****
  		{
  		case GT_EXPR:
  		  return omit_one_operand (type,
! 					   convert (type, integer_zero_node),
  					   arg0);
  		case GE_EXPR:
  		  return fold (build (EQ_EXPR, type, arg0, arg1));

  		case LE_EXPR:
  		  return omit_one_operand (type,
! 					   convert (type, integer_one_node),
  					   arg0);
  		case LT_EXPR:
  		  return fold (build (NE_EXPR, type, arg0, arg1));
--- 7433,7448 ----
  		{
  		case GT_EXPR:
  		  return omit_one_operand (type,
! 					   fold_convert (type,
! 							 integer_zero_node),
  					   arg0);
  		case GE_EXPR:
  		  return fold (build (EQ_EXPR, type, arg0, arg1));

  		case LE_EXPR:
  		  return omit_one_operand (type,
! 					   fold_convert (type,
! 							 integer_one_node),
  					   arg0);
  		case LT_EXPR:
  		  return fold (build (NE_EXPR, type, arg0, arg1));
*************** fold (tree expr)
*** 7337,7350 ****
  		{
  		case LT_EXPR:
  		  return omit_one_operand (type,
! 					   convert (type, integer_zero_node),
  					   arg0);
  		case LE_EXPR:
  		  return fold (build (EQ_EXPR, type, arg0, arg1));

  		case GE_EXPR:
  		  return omit_one_operand (type,
! 					   convert (type, integer_one_node),
  					   arg0);
  		case GT_EXPR:
  		  return fold (build (NE_EXPR, type, arg0, arg1));
--- 7472,7487 ----
  		{
  		case LT_EXPR:
  		  return omit_one_operand (type,
! 					   fold_convert (type,
! 							 integer_zero_node),
  					   arg0);
  		case LE_EXPR:
  		  return fold (build (EQ_EXPR, type, arg0, arg1));

  		case GE_EXPR:
  		  return omit_one_operand (type,
! 					   fold_convert (type,
! 							 integer_one_node),
  					   arg0);
  		case GT_EXPR:
  		  return fold (build (NE_EXPR, type, arg0, arg1));
*************** fold (tree expr)
*** 7381,7388 ****
  		    st1 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg1));
  		    return fold
  		      (build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
! 			      type, convert (st0, arg0),
! 			      convert (st1, integer_zero_node)));
  		  }
  	      }
  	  }
--- 7518,7525 ----
  		    st1 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg1));
  		    return fold
  		      (build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
! 			      type, fold_convert (st0, arg0),
! 			      fold_convert (st1, integer_zero_node)));
  		  }
  	      }
  	  }
*************** fold (tree expr)
*** 7428,7434 ****
  	       && (TREE_TYPE (t1) == TREE_TYPE (tem)
  		   || (TREE_CODE (t1) == INTEGER_CST
  		       && int_fits_type_p (t1, TREE_TYPE (tem)))))
! 	return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));

        /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
  	 constant, we can simplify it.  */
--- 7565,7572 ----
  	       && (TREE_TYPE (t1) == TREE_TYPE (tem)
  		   || (TREE_CODE (t1) == INTEGER_CST
  		       && int_fits_type_p (t1, TREE_TYPE (tem)))))
! 	return fold (build (code, type, tem,
! 			    fold_convert (TREE_TYPE (tem), t1)));

        /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
  	 constant, we can simplify it.  */
*************** fold (tree expr)
*** 7471,7478 ****
  					 TREE_TYPE (TREE_OPERAND (arg0, 0)),
  					 TREE_OPERAND (arg0, 1),
  					 TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
! 				  convert (TREE_TYPE (arg0),
! 					   integer_one_node)),
  			   arg1));
  	  else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
  		   && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
--- 7609,7616 ----
  					 TREE_TYPE (TREE_OPERAND (arg0, 0)),
  					 TREE_OPERAND (arg0, 1),
  					 TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
! 				  fold_convert (TREE_TYPE (arg0),
! 						integer_one_node)),
  			   arg1));
  	  else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
  		   && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
*************** fold (tree expr)
*** 7483,7490 ****
  					 TREE_TYPE (TREE_OPERAND (arg0, 1)),
  					 TREE_OPERAND (arg0, 0),
  					 TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
! 				  convert (TREE_TYPE (arg0),
! 					   integer_one_node)),
  			   arg1));
  	}

--- 7621,7628 ----
  					 TREE_TYPE (TREE_OPERAND (arg0, 1)),
  					 TREE_OPERAND (arg0, 0),
  					 TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
! 				  fold_convert (TREE_TYPE (arg0),
! 						integer_one_node)),
  			   arg1));
  	}

*************** fold (tree expr)
*** 7502,7511 ****
  	{
  	  tree newtype = (*lang_hooks.types.unsigned_type) (TREE_TYPE (arg0));
  	  tree newmod = build (TREE_CODE (arg0), newtype,
! 			       convert (newtype, TREE_OPERAND (arg0, 0)),
! 			       convert (newtype, TREE_OPERAND (arg0, 1)));

! 	  return build (code, type, newmod, convert (newtype, arg1));
  	}

        /* If this is an NE comparison of zero with an AND of one, remove the
--- 7640,7651 ----
  	{
  	  tree newtype = (*lang_hooks.types.unsigned_type) (TREE_TYPE (arg0));
  	  tree newmod = build (TREE_CODE (arg0), newtype,
! 			       fold_convert (newtype,
! 					     TREE_OPERAND (arg0, 0)),
! 			       fold_convert (newtype,
! 					     TREE_OPERAND (arg0, 1)));

! 	  return build (code, type, newmod, fold_convert (newtype, arg1));
  	}

        /* If this is an NE comparison of zero with an AND of one, remove the
*************** fold (tree expr)
*** 7513,7519 ****
        if (code == NE_EXPR && integer_zerop (arg1)
  	  && TREE_CODE (arg0) == BIT_AND_EXPR
  	  && integer_onep (TREE_OPERAND (arg0, 1)))
! 	return convert (type, arg0);

        /* If we have (A & C) == C where C is a power of 2, convert this into
  	 (A & C) != 0.  Similarly for NE_EXPR.  */
--- 7653,7659 ----
        if (code == NE_EXPR && integer_zerop (arg1)
  	  && TREE_CODE (arg0) == BIT_AND_EXPR
  	  && integer_onep (TREE_OPERAND (arg0, 1)))
! 	return fold_convert (type, arg0);

        /* If we have (A & C) == C where C is a power of 2, convert this into
  	 (A & C) != 0.  Similarly for NE_EXPR.  */
*************** fold (tree expr)
*** 7572,7578 ****
  	return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
  		      build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
  			     TREE_OPERAND (arg1, 1)),
! 		      convert (TREE_TYPE (arg0), integer_zero_node));

        else if ((code == LT_EXPR || code == GE_EXPR)
  	       && TREE_UNSIGNED (TREE_TYPE (arg0))
--- 7712,7718 ----
  	return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
  		      build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
  			     TREE_OPERAND (arg1, 1)),
! 		      fold_convert (TREE_TYPE (arg0), integer_zero_node));

        else if ((code == LT_EXPR || code == GE_EXPR)
  	       && TREE_UNSIGNED (TREE_TYPE (arg0))
*************** fold (tree expr)
*** 7582,7591 ****
  	       && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
  	return
  	  build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
! 		 convert (TREE_TYPE (arg0),
! 			  build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
! 				 TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
! 		 convert (TREE_TYPE (arg0), integer_zero_node));

        /* Simplify comparison of something with itself.  (For IEEE
  	 floating-point, we can only do some of these simplifications.)  */
--- 7722,7732 ----
  	       && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
  	return
  	  build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
! 		 fold_convert (TREE_TYPE (arg0),
! 			       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
! 				      TREE_OPERAND (TREE_OPERAND (arg1, 0),
! 						    1))),
! 		 fold_convert (TREE_TYPE (arg0), integer_zero_node));

        /* Simplify comparison of something with itself.  (For IEEE
  	 floating-point, we can only do some of these simplifications.)  */
*************** fold (tree expr)
*** 7936,7967 ****
  	    switch (comp_code)
  	      {
  	      case EQ_EXPR:
! 		return
! 		  pedantic_non_lvalue
! 		    (convert (type,
! 			      negate_expr
! 			      (convert (TREE_TYPE (TREE_OPERAND (t, 1)),
! 					arg1))));
  	      case NE_EXPR:
! 		return pedantic_non_lvalue (convert (type, arg1));
  	      case GE_EXPR:
  	      case GT_EXPR:
  		if (TREE_UNSIGNED (TREE_TYPE (arg1)))
! 		  arg1 = convert ((*lang_hooks.types.signed_type)
! 				  (TREE_TYPE (arg1)), arg1);
! 		return pedantic_non_lvalue
! 		  (convert (type, fold (build1 (ABS_EXPR,
! 						TREE_TYPE (arg1), arg1))));
  	      case LE_EXPR:
  	      case LT_EXPR:
  		if (TREE_UNSIGNED (TREE_TYPE (arg1)))
  		  arg1 = convert ((lang_hooks.types.signed_type)
  				  (TREE_TYPE (arg1)), arg1);
! 		return pedantic_non_lvalue
! 		  (negate_expr (convert (type,
! 					 fold (build1 (ABS_EXPR,
! 						       TREE_TYPE (arg1),
! 						       arg1)))));
  	      default:
  		abort ();
  	      }
--- 8077,8102 ----
  	    switch (comp_code)
  	      {
  	      case EQ_EXPR:
! 		tem = fold_convert (TREE_TYPE (TREE_OPERAND (t, 1)), arg1);
! 		tem = fold_convert (type, negate_expr (tem));
! 		return pedantic_non_lvalue (tem);
  	      case NE_EXPR:
! 		return pedantic_non_lvalue (fold_convert (type, arg1));
  	      case GE_EXPR:
  	      case GT_EXPR:
  		if (TREE_UNSIGNED (TREE_TYPE (arg1)))
! 		  arg1 = fold_convert ((*lang_hooks.types.signed_type)
! 				       (TREE_TYPE (arg1)), arg1);
! 		arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
! 		return pedantic_non_lvalue (fold_convert (type, arg1));
  	      case LE_EXPR:
  	      case LT_EXPR:
  		if (TREE_UNSIGNED (TREE_TYPE (arg1)))
  		  arg1 = convert ((lang_hooks.types.signed_type)
  				  (TREE_TYPE (arg1)), arg1);
! 		arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
! 		arg1 = negate_expr (fold_convert (type, arg1));
! 		return pedantic_non_lvalue (arg1);
  	      default:
  		abort ();
  	      }
*************** fold (tree expr)
*** 7974,7982 ****
  	  if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
  	    {
  	      if (comp_code == NE_EXPR)
! 		return pedantic_non_lvalue (convert (type, arg1));
  	      else if (comp_code == EQ_EXPR)
! 		return pedantic_non_lvalue (convert (type, integer_zero_node));
  	    }

  	  /* Try some transformations of A op B ? A : B.
--- 8109,8117 ----
  	  if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
  	    {
  	      if (comp_code == NE_EXPR)
! 		return pedantic_non_lvalue (fold_convert (type, arg1));
  	      else if (comp_code == EQ_EXPR)
! 		return pedantic_non_lvalue (fold_convert (type, integer_zero_node));
  	    }

  	  /* Try some transformations of A op B ? A : B.
*************** fold (tree expr)
*** 8023,8031 ****
  	      switch (comp_code)
  		{
  		case EQ_EXPR:
! 		  return pedantic_non_lvalue (convert (type, arg2));
  		case NE_EXPR:
! 		  return pedantic_non_lvalue (convert (type, arg1));
  		case LE_EXPR:
  		case LT_EXPR:
  		  /* In C++ a ?: expression can be an lvalue, so put the
--- 8158,8166 ----
  	      switch (comp_code)
  		{
  		case EQ_EXPR:
! 		  return pedantic_non_lvalue (fold_convert (type, arg2));
  		case NE_EXPR:
! 		  return pedantic_non_lvalue (fold_convert (type, arg1));
  		case LE_EXPR:
  		case LT_EXPR:
  		  /* In C++ a ?: expression can be an lvalue, so put the
*************** fold (tree expr)
*** 8033,8054 ****
  		     so that we can convert this back to the
  		     corresponding COND_EXPR.  */
  		  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
! 		    return pedantic_non_lvalue
! 		      (convert (type, fold (build (MIN_EXPR, comp_type,
! 						   (comp_code == LE_EXPR
! 						    ? comp_op0 : comp_op1),
! 						   (comp_code == LE_EXPR
! 						    ? comp_op1 : comp_op0)))));
  		  break;
  		case GE_EXPR:
  		case GT_EXPR:
  		  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
! 		    return pedantic_non_lvalue
! 		      (convert (type, fold (build (MAX_EXPR, comp_type,
! 						   (comp_code == GE_EXPR
! 						    ? comp_op0 : comp_op1),
! 						   (comp_code == GE_EXPR
! 						    ? comp_op1 : comp_op0)))));
  		  break;
  		default:
  		  abort ();
--- 8168,8189 ----
  		     so that we can convert this back to the
  		     corresponding COND_EXPR.  */
  		  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
! 		    return pedantic_non_lvalue (fold_convert
! 		      (type, fold (build (MIN_EXPR, comp_type,
! 					  (comp_code == LE_EXPR
! 					   ? comp_op0 : comp_op1),
! 					  (comp_code == LE_EXPR
! 					   ? comp_op1 : comp_op0)))));
  		  break;
  		case GE_EXPR:
  		case GT_EXPR:
  		  if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
! 		    return pedantic_non_lvalue (fold_convert
! 		      (type, fold (build (MAX_EXPR, comp_type,
! 					  (comp_code == GE_EXPR
! 					   ? comp_op0 : comp_op1),
! 					  (comp_code == GE_EXPR
! 					   ? comp_op1 : comp_op0)))));
  		  break;
  		default:
  		  abort ();
*************** fold (tree expr)
*** 8068,8074 ****
  	      {
  	      case EQ_EXPR:
  		/* We can replace A with C1 in this case.  */
! 		arg1 = convert (type, TREE_OPERAND (arg0, 1));
  		return fold (build (code, type, TREE_OPERAND (t, 0), arg1,
  				    TREE_OPERAND (t, 2)));

--- 8203,8209 ----
  	      {
  	      case EQ_EXPR:
  		/* We can replace A with C1 in this case.  */
! 		arg1 = fold_convert (type, TREE_OPERAND (arg0, 1));
  		return fold (build (code, type, TREE_OPERAND (t, 0), arg1,
  				    TREE_OPERAND (t, 2)));

*************** fold (tree expr)
*** 8148,8155 ****
        if (integer_zerop (TREE_OPERAND (t, 1))
  	  && integer_onep (TREE_OPERAND (t, 2))
  	  && truth_value_p (TREE_CODE (arg0)))
! 	return pedantic_non_lvalue (convert (type,
! 					     invert_truthvalue (arg0)));

        /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
  	 operation is simply A & 2.  */
--- 8283,8290 ----
        if (integer_zerop (TREE_OPERAND (t, 1))
  	  && integer_onep (TREE_OPERAND (t, 2))
  	  && truth_value_p (TREE_CODE (arg0)))
! 	return pedantic_non_lvalue (fold_convert (type,
! 						  invert_truthvalue (arg0)));

        /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
  	 operation is simply A & 2.  */
*************** fold (tree expr)
*** 8161,8167 ****
  	  && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
  	  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
  			      arg1, 1))
! 	return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));

        /* Convert A ? B : 0 into A && B if A and B are truth values.  */
        if (integer_zerop (TREE_OPERAND (t, 2))
--- 8296,8303 ----
  	  && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
  	  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
  			      arg1, 1))
! 	return pedantic_non_lvalue (fold_convert (type,
! 						  TREE_OPERAND (arg0, 0)));

        /* Convert A ? B : 0 into A && B if A and B are truth values.  */
        if (integer_zerop (TREE_OPERAND (t, 2))
*************** fold (tree expr)
*** 8190,8198 ****
        if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
  	return t;
        /* Don't let (0, 0) be null pointer constant.  */
!       if (integer_zerop (arg1))
! 	return pedantic_non_lvalue (build1 (NOP_EXPR, type, arg1));
!       return pedantic_non_lvalue (convert (type, arg1));

      case COMPLEX_EXPR:
        if (wins)
--- 8326,8334 ----
        if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
  	return t;
        /* Don't let (0, 0) be null pointer constant.  */
!       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
! 				 : fold_convert (type, arg1);
!       return pedantic_non_lvalue (tem);

      case COMPLEX_EXPR:
        if (wins)
*************** fold (tree expr)
*** 8217,8223 ****

      case IMAGPART_EXPR:
        if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
! 	return convert (type, integer_zero_node);
        else if (TREE_CODE (arg0) == COMPLEX_EXPR)
  	return omit_one_operand (type, TREE_OPERAND (arg0, 1),
  				 TREE_OPERAND (arg0, 0));
--- 8353,8359 ----

      case IMAGPART_EXPR:
        if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
! 	return fold_convert (type, integer_zero_node);
        else if (TREE_CODE (arg0) == COMPLEX_EXPR)
  	return omit_one_operand (type, TREE_OPERAND (arg0, 1),
  				 TREE_OPERAND (arg0, 0));
*************** multiple_of_p (tree type, tree top, tree
*** 8579,8587 ****
  	  if (TYPE_PRECISION (TREE_TYPE (size_one_node))
  	      > TREE_INT_CST_LOW (op1)
  	      && TREE_INT_CST_HIGH (op1) == 0
! 	      && 0 != (t1 = convert (type,
! 				     const_binop (LSHIFT_EXPR, size_one_node,
! 						  op1, 0)))
  	      && ! TREE_OVERFLOW (t1))
  	    return multiple_of_p (type, t1, bottom);
  	}
--- 8715,8724 ----
  	  if (TYPE_PRECISION (TREE_TYPE (size_one_node))
  	      > TREE_INT_CST_LOW (op1)
  	      && TREE_INT_CST_HIGH (op1) == 0
! 	      && 0 != (t1 = fold_convert (type,
! 					  const_binop (LSHIFT_EXPR,
! 						       size_one_node,
! 						       op1, 0)))
  	      && ! TREE_OVERFLOW (t1))
  	    return multiple_of_p (type, t1, bottom);
  	}



// PR middle-end/13696
// { dg-do compile }
// { dg-options "-O2" }

extern void x(unsigned long*);

enum e { red, blue, green };

struct s {
  unsigned long l;
};
struct s map[1][256];

void
f(int i,e j) {
     x(&(map[i][j].l));
}


Roger
--
Roger Sayle,                         E-mail: roger@eyesopen.com
OpenEye Scientific Software,         WWW: http://www.eyesopen.com/
Suite 1107, 3600 Cerrillos Road,     Tel: (+1) 505-473-7385
Santa Fe, New Mexico, 87507.         Fax: (+1) 505-473-0833


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]