Patchwork rfc NOP vs CONVERT (was: Simplifying Gimple Generation)

login
register
mail settings
Submitter Michael Matz
Date Nov. 19, 2012, 3:35 p.m.
Message ID <alpine.LNX.2.00.1211191632510.21868@wotan.suse.de>
Download mbox | patch
Permalink /patch/200035/
State New
Headers show

Comments

Michael Matz - Nov. 19, 2012, 3:35 p.m.
Hi,

On Mon, 19 Nov 2012, Steven Bosscher wrote:

> On Mon, Nov 19, 2012 at 2:10 PM, Michael Matz wrote:
> > Hi,
> >
> > On Fri, 16 Nov 2012, Andrew Pinski wrote:
> >
> >> >> Ah, yes.  This one was amusing.  When we were drafting the proposal,
> >> >> Lawrence kept wondering what this NOP_EXPR thing is.  I've been
> >> >> suffering this name for so long, that it no longer irritates me.
> >> >> Had it been named CAST_EXPR, or even NOP_CAST_EXPR, he would have
> >> >> probably kept it in the example code :)
> >> >
> >> > We have CONVERT_EXPR, but it currently doesn't do _quite_ the same as
> >> > NOP_EXPR.  I once wanted to merge them (with CONVERT_EXPR surviving),
> >> > but it stalled somewhere, couple years ago.
> >>
> >> I think the only difference now is in the front-ends IIRC.
> >
> > No, because my patch didn't go in.  There are still various cases in the
> > middle end that explicitely check for equality with NOP_EXPR, instead of
> > using CONVERT_EXPR_P or CONVERT_EXPR_CODE_P or CASE_CONVERT to work with
> > both.
> >
> > See the patch below from three years ago.  Of course it doesn't apply
> > anymore, but I can update it if there's some consensus that we want to go
> > that route.
> 
> At this point, you probably wanted to attach a patch :-)

I thought everybody can look into my head.  Well, if you can't 
due to my aluminium hat, here it is electronically :)


Ciao,
Michael.
Diego Novillo - Nov. 20, 2012, 9:23 p.m.
On Mon, Nov 19, 2012 at 10:35 AM, Michael Matz <matz@suse.de> wrote:

> I thought everybody can look into my head.  Well, if you can't
> due to my aluminium hat, here it is electronically :)

Thanks.  Looks fine with the appropriate ChangeLog entry.


Diego.
Martin Jambor - Nov. 20, 2012, 9:36 p.m.
Hi,

On Mon, Nov 19, 2012 at 04:35:45PM +0100, Michael Matz wrote:
> Hi,
> 
> On Mon, 19 Nov 2012, Steven Bosscher wrote:
> 
> > On Mon, Nov 19, 2012 at 2:10 PM, Michael Matz wrote:
> > > Hi,
> > >
> > > On Fri, 16 Nov 2012, Andrew Pinski wrote:
> > >
> > >> >> Ah, yes.  This one was amusing.  When we were drafting the proposal,
> > >> >> Lawrence kept wondering what this NOP_EXPR thing is.  I've been
> > >> >> suffering this name for so long, that it no longer irritates me.
> > >> >> Had it been named CAST_EXPR, or even NOP_CAST_EXPR, he would have
> > >> >> probably kept it in the example code :)
> > >> >
> > >> > We have CONVERT_EXPR, but it currently doesn't do _quite_ the same as
> > >> > NOP_EXPR.  I once wanted to merge them (with CONVERT_EXPR surviving),
> > >> > but it stalled somewhere, couple years ago.
> > >>
> > >> I think the only difference now is in the front-ends IIRC.
> > >
> > > No, because my patch didn't go in.  There are still various cases in the
> > > middle end that explicitely check for equality with NOP_EXPR, instead of
> > > using CONVERT_EXPR_P or CONVERT_EXPR_CODE_P or CASE_CONVERT to work with
> > > both.
> > >
> > > See the patch below from three years ago.  Of course it doesn't apply
> > > anymore, but I can update it if there's some consensus that we want to go
> > > that route.
> > 
> > At this point, you probably wanted to attach a patch :-)
> 
> I thought everybody can look into my head.  Well, if you can't 
> due to my aluminium hat, here it is electronically :)
> 

thanks, this way it's certainly easier to quote :-)

...

> Index: gcc/ipa-cp.c
> ===================================================================
> --- gcc.orig/ipa-cp.c	2009-08-17 10:53:09.000000000 +0200
> +++ gcc/ipa-cp.c	2009-09-29 15:29:05.000000000 +0200
> @@ -298,7 +298,7 @@ ipcp_lattice_from_jfunc (struct ipa_node
>  	return;
>        cst = caller_lat->constant;
>  
> -      if (jfunc->value.pass_through.operation != NOP_EXPR)
> +      if (! CONVERT_EXPR_CODE_P (jfunc->value.pass_through.operation))
>  	cst = fold_binary (jfunc->value.pass_through.operation,
>  			   TREE_TYPE (cst), cst,
>  			   jfunc->value.pass_through.operand);

This will of course work but it is a bit strange, jump functions do
not do any conversions, NOP_EXPR operation really means they do
nothing to the value they pass.  Similarly in ipa-prop.c.

Thanks,

Martin
Michael Matz - Nov. 21, 2012, 1:12 p.m.
Hi,

On Tue, 20 Nov 2012, Martin Jambor wrote:

> > +++ gcc/ipa-cp.c	2009-09-29 15:29:05.000000000 +0200
> > @@ -298,7 +298,7 @@ ipcp_lattice_from_jfunc (struct ipa_node
> >  	return;
> >        cst = caller_lat->constant;
> >  
> > -      if (jfunc->value.pass_through.operation != NOP_EXPR)
> > +      if (! CONVERT_EXPR_CODE_P (jfunc->value.pass_through.operation))
> >  	cst = fold_binary (jfunc->value.pass_through.operation,
> >  			   TREE_TYPE (cst), cst,
> >  			   jfunc->value.pass_through.operand);
> 
> This will of course work but it is a bit strange, jump functions do
> not do any conversions, NOP_EXPR operation really means they do
> nothing to the value they pass.  Similarly in ipa-prop.c.

I see.  So you're using NOP_EXPR really just as marker tree code not with 
its usual semantics (which includes conversions).  My goal really was to 
totally get rid of any mention of NOP_EXPR starting with the middle end, 
with the next goal then being to exclusively use CONVERT_EXPR everywhere.

So, while looking strange, I think IPA could also work with that marker 
being CONVERT_EXPR ultimately.  Deserves a comment, though.  And hey, who 
knows, perhaps eventually the jump functions could also express value 
conversion :)


Ciao,
Michael.

Patch

Index: gcc/builtins.c
===================================================================
--- gcc.orig/builtins.c	2009-09-28 13:06:24.000000000 +0200
+++ gcc/builtins.c	2009-09-29 15:01:44.000000000 +0200
@@ -6873,7 +6873,7 @@  fold_builtin_expect (location_t loc, tre
   /* Distribute the expected value over short-circuiting operators.
      See through the cast from truthvalue_type_node to long.  */
   inner = arg0;
-  while (TREE_CODE (inner) == NOP_EXPR
+  while (CONVERT_EXPR_P (inner)
 	 && INTEGRAL_TYPE_P (TREE_TYPE (inner))
 	 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
     inner = TREE_OPERAND (inner, 0);
@@ -7028,7 +7028,7 @@  integer_valued_real_p (tree t)
     case REAL_CST:
       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
 
-    case NOP_EXPR:
+    CASE_CONVERT:
       {
 	tree type = TREE_TYPE (TREE_OPERAND (t, 0));
 	if (TREE_CODE (type) == INTEGER_TYPE)
@@ -13843,7 +13843,7 @@  fold_call_stmt (gimple stmt, bool ignore
 	      if (gimple_has_location (stmt))
                 {
 		  tree realret = ret;
-		  if (TREE_CODE (ret) == NOP_EXPR)
+		  if (CONVERT_EXPR_P (ret))
 		    realret = TREE_OPERAND (ret, 0);
 		  if (CAN_HAVE_LOCATION_P (realret)
 		      && !EXPR_HAS_LOCATION (realret))
Index: gcc/c-common.c
===================================================================
--- gcc.orig/c-common.c	2009-09-24 14:54:14.000000000 +0200
+++ gcc/c-common.c	2009-09-29 15:02:49.000000000 +0200
@@ -8348,7 +8348,7 @@  fold_offsetof_1 (tree expr, tree stop_re
       gcc_assert (integer_zerop (expr));
       return size_zero_node;
 
-    case NOP_EXPR:
+    CASE_CONVERT:
     case INDIRECT_REF:
       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
       gcc_assert (base == error_mark_node || base == size_zero_node);
Index: gcc/c-omp.c
===================================================================
--- gcc.orig/c-omp.c	2009-07-20 07:12:40.000000000 +0200
+++ gcc/c-omp.c	2009-09-29 15:04:13.000000000 +0200
@@ -318,7 +318,7 @@  c_finish_omp_for (location_t locus, tree
 
 		 We want to force:
 		 i < (int)n;  */
-	      if (TREE_CODE (op0) == NOP_EXPR
+	      if (CONVERT_EXPR_P (op0)
 		  && decl == TREE_OPERAND (op0, 0))
 		{
 		  TREE_OPERAND (cond, 0) = TREE_OPERAND (op0, 0);
@@ -326,7 +326,7 @@  c_finish_omp_for (location_t locus, tree
 		    = fold_build1_loc (elocus, NOP_EXPR, TREE_TYPE (decl),
 				   TREE_OPERAND (cond, 1));
 		}
-	      else if (TREE_CODE (op1) == NOP_EXPR
+	      else if (CONVERT_EXPR_P (op1)
 		       && decl == TREE_OPERAND (op1, 0))
 		{
 		  TREE_OPERAND (cond, 1) = TREE_OPERAND (op1, 0);
Index: gcc/c-pretty-print.c
===================================================================
--- gcc.orig/c-pretty-print.c	2009-09-15 15:02:55.000000000 +0200
+++ gcc/c-pretty-print.c	2009-09-29 15:07:48.000000000 +0200
@@ -992,8 +992,8 @@  pp_c_complex_expr (c_pretty_printer *pp,
   tree imagexpr = TREE_OPERAND (e, 1);
 
   /* Cast of an COMPLEX_TYPE expression to a different COMPLEX_TYPE.  */
-  if (TREE_CODE (realexpr) == NOP_EXPR
-      && TREE_CODE (imagexpr) == NOP_EXPR
+  if (CONVERT_EXPR_P (realexpr)
+      && CONVERT_EXPR_P (imagexpr)
       && TREE_TYPE (realexpr) == TREE_TYPE (type)
       && TREE_TYPE (imagexpr) == TREE_TYPE (type)
       && TREE_CODE (TREE_OPERAND (realexpr, 0)) == REALPART_EXPR
@@ -1011,7 +1011,7 @@  pp_c_complex_expr (c_pretty_printer *pp,
       && TREE_TYPE (realexpr) == TREE_TYPE (type))
     {
       pp_c_type_cast (pp, type);
-      if (TREE_CODE (realexpr) == NOP_EXPR)
+      if (CONVERT_EXPR_P (realexpr))
 	realexpr = TREE_OPERAND (realexpr, 0);
       pp_expression (pp, realexpr);
       return;
Index: gcc/c-typeck.c
===================================================================
--- gcc.orig/c-typeck.c	2009-09-28 13:30:24.000000000 +0200
+++ gcc/c-typeck.c	2009-09-29 15:56:14.000000000 +0200
@@ -2630,7 +2630,7 @@  build_function_call_vec (location_t loc,
       else
 	result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
 					    function, nargs, argarray);
-      if (TREE_CODE (result) == NOP_EXPR
+      if (CONVERT_EXPR_P (result)
 	  && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
 	STRIP_TYPE_NOPS (result);
     }
@@ -3193,7 +3193,7 @@  build_unary_op (location_t location,
 
   switch (code)
     {
-    case CONVERT_EXPR:
+    CASE_CONVERT:
       /* This is used for unary plus, because a CONVERT_EXPR
 	 is enough to prevent anybody from looking inside for
 	 associativity, but won't generate any code.  */
@@ -4537,6 +4537,7 @@  build_modify_expr (location_t location,
   /* If a binary op has been requested, combine the old LHS value with the RHS
      producing the value we should actually store into the LHS.  */
 
+  gcc_assert (modifycode != CONVERT_EXPR);
   if (modifycode != NOP_EXPR)
     {
       lhs = c_fully_fold (lhs, false, NULL);
@@ -8693,7 +8694,7 @@  c_finish_stmt_expr (location_t loc, tree
   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
      tree_expr_nonnegative_p giving up immediately.  */
   val = last;
-  if (TREE_CODE (val) == NOP_EXPR
+  if (CONVERT_EXPR_P (val)
       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
     val = TREE_OPERAND (val, 0);
 
Index: gcc/cfgexpand.c
===================================================================
--- gcc.orig/cfgexpand.c	2009-09-24 14:54:14.000000000 +0200
+++ gcc/cfgexpand.c	2009-09-29 15:03:33.000000000 +0200
@@ -2383,8 +2383,7 @@  expand_debug_expr (tree exp)
 
     adjust_mode:
     case PAREN_EXPR:
-    case NOP_EXPR:
-    case CONVERT_EXPR:
+    CASE_CONVERT:
       {
 	enum machine_mode inner_mode = GET_MODE (op0);
 
Index: gcc/convert.c
===================================================================
--- gcc.orig/convert.c	2009-08-25 08:12:36.000000000 +0200
+++ gcc/convert.c	2009-09-29 15:05:16.000000000 +0200
@@ -772,7 +772,7 @@  convert_to_integer (tree type, tree expr
 						  TREE_OPERAND (expr, 0))));
 	  }
 
-	case NOP_EXPR:
+	CASE_CONVERT:
 	  /* Don't introduce a
 	     "can't convert between vector values of different size" error.  */
 	  if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == VECTOR_TYPE
Index: gcc/dojump.c
===================================================================
--- gcc.orig/dojump.c	2009-08-27 18:33:37.000000000 +0200
+++ gcc/dojump.c	2009-09-29 15:13:38.000000000 +0200
@@ -363,13 +363,12 @@  do_jump (tree exp, rtx if_false_label, r
       break;
 #endif
 
-    case NOP_EXPR:
+    CASE_CONVERT:
       if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
           || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
           || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF
           || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_RANGE_REF)
         goto normal;
-    case CONVERT_EXPR:
       /* If we are narrowing the operand, we have to do the compare in the
          narrower mode.  */
       if ((TYPE_PRECISION (TREE_TYPE (exp))
Index: gcc/except.c
===================================================================
--- gcc.orig/except.c	2009-09-15 15:02:55.000000000 +0200
+++ gcc/except.c	2009-09-29 15:15:06.000000000 +0200
@@ -674,6 +674,7 @@  add_type_for_runtime (tree type)
   tree *slot;
 
   /* If TYPE is NOP_EXPR, it means that it already is a runtime type.  */
+  gcc_assert (TREE_CODE (type) != CONVERT_EXPR);
   if (TREE_CODE (type) == NOP_EXPR)
     return;
 
@@ -692,6 +693,7 @@  lookup_type_for_runtime (tree type)
   tree *slot;
 
   /* If TYPE is NOP_EXPR, it means that it already is a runtime type.  */
+  gcc_assert (TREE_CODE (type) != CONVERT_EXPR);
   if (TREE_CODE (type) == NOP_EXPR)
     return type;
 
Index: gcc/fold-const.c
===================================================================
--- gcc.orig/fold-const.c	2009-09-28 13:30:24.000000000 +0200
+++ gcc/fold-const.c	2009-09-29 15:55:34.000000000 +0200
@@ -1197,7 +1197,7 @@  negate_expr_p (tree t)
       return negate_expr_p (TREE_OPERAND (t, 1))
              || negate_expr_p (TREE_OPERAND (t, 0));
 
-    case NOP_EXPR:
+    CASE_CONVERT:
       /* Negate -((double)float) as (double)(-float).  */
       if (TREE_CODE (type) == REAL_TYPE)
 	{
@@ -1388,7 +1388,7 @@  fold_negate_expr (location_t loc, tree t
         }
       break;
 
-    case NOP_EXPR:
+    CASE_CONVERT:
       /* Convert -((double)float) into (double)(-float).  */
       if (TREE_CODE (type) == REAL_TYPE)
 	{
@@ -4471,7 +4471,7 @@  sign_bit_p (tree exp, const_tree val)
     return exp;
 
   /* Handle extension from a narrower type.  */
-  if (TREE_CODE (exp) == NOP_EXPR
+  if (CONVERT_EXPR_P (exp)
       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
     return sign_bit_p (TREE_OPERAND (exp, 0), val);
 
@@ -8626,8 +8626,8 @@  fold_unary_loc (location_t loc, enum tre
       if (POINTER_TYPE_P (type)
 	  && TREE_CODE (arg0) == POINTER_PLUS_EXPR
 	  && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
-	      || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
-	      || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
+	      || CONVERT_EXPR_P (TREE_OPERAND (arg0, 0))
+	      || CONVERT_EXPR_P (TREE_OPERAND (arg0, 1))))
 	{
 	  tree arg00 = TREE_OPERAND (arg0, 0);
 	  tree arg01 = TREE_OPERAND (arg0, 1);
@@ -8727,7 +8727,7 @@  fold_unary_loc (location_t loc, enum tre
       else if (TREE_CODE (arg0) == NEGATE_EXPR)
 	return fold_build1_loc (loc, ABS_EXPR, type, TREE_OPERAND (arg0, 0));
       /* Convert fabs((double)float) into (double)fabsf(float).  */
-      else if (TREE_CODE (arg0) == NOP_EXPR
+      else if (CONVERT_EXPR_P (arg0)
 	       && TREE_CODE (type) == REAL_TYPE)
 	{
 	  tree targ0 = strip_float_extensions (arg0);
@@ -11649,7 +11649,7 @@  fold_binary_loc (location_t loc,
       if (t1 != NULL_TREE)
 	return t1;
       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
-      if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
+      if (TREE_CODE (arg1) == INTEGER_CST && CONVERT_EXPR_P (arg0)
 	  && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
 	{
 	  unsigned int prec
@@ -11725,7 +11725,7 @@  fold_binary_loc (location_t loc,
 	      tree arg00 = TREE_OPERAND (arg0, 0);
 	      /* See if more bits can be proven as zero because of
 		 zero extension.  */
-	      if (TREE_CODE (arg00) == NOP_EXPR
+	      if (CONVERT_EXPR_P (arg00)
 		  && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
 		{
 		  tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
@@ -14771,7 +14771,7 @@  multiple_of_p (tree type, const_tree top
 	}
       return 0;
 
-    case NOP_EXPR:
+    CASE_CONVERT:
       /* Can't handle conversions from non-integral or wider integral type.  */
       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
 	  || (TYPE_PRECISION (type)
@@ -14843,7 +14843,7 @@  tree_unary_nonnegative_warnv_p (enum tre
       return tree_expr_nonnegative_warnv_p (op0,
 					    strict_overflow_p);
 
-    case NOP_EXPR:
+    CASE_CONVERT:
       {
 	tree inner_type = TREE_TYPE (op0);
 	tree outer_type = type;
@@ -14906,8 +14906,8 @@  tree_binary_nonnegative_warnv_p (enum tr
       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
 	 both unsigned and at least 2 bits shorter than the result.  */
       if (TREE_CODE (type) == INTEGER_TYPE
-	  && TREE_CODE (op0) == NOP_EXPR
-	  && TREE_CODE (op1) == NOP_EXPR)
+	  && CONVERT_EXPR_P (op0)
+	  && CONVERT_EXPR_P (op1))
 	{
 	  tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
 	  tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
@@ -14936,13 +14936,13 @@  tree_binary_nonnegative_warnv_p (enum tr
       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
 	 both unsigned and their total bits is shorter than the result.  */
       if (TREE_CODE (type) == INTEGER_TYPE
-	  && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
-	  && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
+	  && (CONVERT_EXPR_P (op0) || TREE_CODE (op0) == INTEGER_CST)
+	  && (CONVERT_EXPR_P (op1) || TREE_CODE (op1) == INTEGER_CST))
 	{
-	  tree inner0 = (TREE_CODE (op0) == NOP_EXPR) 
+	  tree inner0 = CONVERT_EXPR_P (op0) 
 	    ? TREE_TYPE (TREE_OPERAND (op0, 0))
 	    : TREE_TYPE (op0);
-	  tree inner1 = (TREE_CODE (op1) == NOP_EXPR) 
+	  tree inner1 = CONVERT_EXPR_P (op1)
 	    ? TREE_TYPE (TREE_OPERAND (op1, 0))
 	    : TREE_TYPE (op1);
 
@@ -15353,7 +15353,7 @@  tree_unary_nonzero_warnv_p (enum tree_co
       return tree_expr_nonzero_warnv_p (op0,
 					strict_overflow_p);
 
-    case NOP_EXPR:
+    CASE_CONVERT:
       {
 	tree inner_type = TREE_TYPE (op0);
 	tree outer_type = type;
Index: gcc/gimple.c
===================================================================
--- gcc.orig/gimple.c	2009-09-15 15:02:55.000000000 +0200
+++ gcc/gimple.c	2009-09-29 15:27:24.000000000 +0200
@@ -2927,7 +2927,7 @@  tree
 canonicalize_cond_expr_cond (tree t)
 {
   /* For (bool)x use x != 0.  */
-  if (TREE_CODE (t) == NOP_EXPR
+  if (CONVERT_EXPR_P (t)
       && TREE_TYPE (t) == boolean_type_node)
     {
       tree top0 = TREE_OPERAND (t, 0);
Index: gcc/gimplify.c
===================================================================
--- gcc.orig/gimplify.c	2009-09-15 15:02:55.000000000 +0200
+++ gcc/gimplify.c	2009-09-29 15:28:01.000000000 +0200
@@ -6966,7 +6966,7 @@  gimplify_expr (tree *expr_p, gimple_seq
 	      break;
 	    }
 	  /* Convert (void *)&a + 4 into (void *)&a[1].  */
-	  if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
+	  if (CONVERT_EXPR_P (TREE_OPERAND (*expr_p, 0))
 	      && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
 	      && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p,
 									0),0)))
Index: gcc/ipa-cp.c
===================================================================
--- gcc.orig/ipa-cp.c	2009-08-17 10:53:09.000000000 +0200
+++ gcc/ipa-cp.c	2009-09-29 15:29:05.000000000 +0200
@@ -298,7 +298,7 @@  ipcp_lattice_from_jfunc (struct ipa_node
 	return;
       cst = caller_lat->constant;
 
-      if (jfunc->value.pass_through.operation != NOP_EXPR)
+      if (! CONVERT_EXPR_CODE_P (jfunc->value.pass_through.operation))
 	cst = fold_binary (jfunc->value.pass_through.operation,
 			   TREE_TYPE (cst), cst,
 			   jfunc->value.pass_through.operand);
Index: gcc/ipa-inline.c
===================================================================
--- gcc.orig/ipa-inline.c	2009-09-20 22:05:01.000000000 +0200
+++ gcc/ipa-inline.c	2009-09-29 15:29:34.000000000 +0200
@@ -1674,8 +1674,7 @@  likely_eliminated_by_inlining_p (gimple
 	/* Casts of parameters, loads from parameters passed by reference
 	   and stores to return value or parameters are probably free after
 	   inlining.  */
-	if (gimple_assign_rhs_code (stmt) == CONVERT_EXPR
-	    || gimple_assign_rhs_code (stmt) == NOP_EXPR
+	if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
 	    || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR
 	    || gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
 	  {
Index: gcc/ipa-prop.c
===================================================================
--- gcc.orig/ipa-prop.c	2009-08-17 10:53:09.000000000 +0200
+++ gcc/ipa-prop.c	2009-09-29 15:30:58.000000000 +0200
@@ -304,7 +304,7 @@  ipa_print_node_jump_functions (FILE *f,
 		       jump_func->value.pass_through.formal_id,
 		       tree_code_name[(int)
 				      jump_func->value.pass_through.operation]);
-	      if (jump_func->value.pass_through.operation != NOP_EXPR)
+	      if (! CONVERT_EXPR_CODE_P (jump_func->value.pass_through.operation))
 		print_generic_expr (dump_file,
 				    jump_func->value.pass_through.operand, 0);
 	      fprintf (dump_file, "\n");
@@ -997,7 +997,7 @@  update_jump_functions_after_inlining (st
 
       /* We must check range due to calls with variable number of arguments and
 	 we cannot combine jump functions with operations.  */
-      if (dst->value.pass_through.operation != NOP_EXPR
+      if (! CONVERT_EXPR_CODE_P (dst->value.pass_through.operation)
 	  || (dst->value.pass_through.formal_id
 	      >= ipa_get_cs_argument_count (top)))
 	{
@@ -1064,7 +1064,7 @@  update_call_notes_after_inlining (struct
 
       jfunc = ipa_get_ith_jump_func (top, nt->formal_id);
       if (jfunc->type == IPA_JF_PASS_THROUGH
-	  && jfunc->value.pass_through.operation == NOP_EXPR)
+	  && CONVERT_EXPR_CODE_P (jfunc->value.pass_through.operation))
 	nt->formal_id = jfunc->value.pass_through.formal_id;
       else if (jfunc->type == IPA_JF_CONST
 	       || jfunc->type == IPA_JF_CONST_MEMBER_PTR)
Index: gcc/tree-affine.c
===================================================================
--- gcc.orig/tree-affine.c	2009-04-05 08:06:20.000000000 +0200
+++ gcc/tree-affine.c	2009-09-29 15:32:14.000000000 +0200
@@ -588,7 +588,7 @@  aff_combination_expand (aff_tree *comb A
       type = TREE_TYPE (e);
       name = e;
       /* Look through some conversions.  */
-      if (TREE_CODE (e) == NOP_EXPR
+      if (CONVERT_EXPR_P (e)
           && (TYPE_PRECISION (type)
 	      >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (e, 0)))))
 	name = TREE_OPERAND (e, 0);
Index: gcc/tree-data-ref.c
===================================================================
--- gcc.orig/tree-data-ref.c	2009-08-06 08:00:59.000000000 +0200
+++ gcc/tree-data-ref.c	2009-09-29 15:33:23.000000000 +0200
@@ -1924,7 +1924,7 @@  initialize_matrix_A (lambda_matrix A, tr
 	return chrec_fold_op (TREE_CODE (chrec), chrec_type (chrec), op0, op1);
       }
 
-    case NOP_EXPR:
+    CASE_CONVERT:
       {
 	tree op = initialize_matrix_A (A, TREE_OPERAND (chrec, 0), index, mult);
 	return chrec_convert (chrec_type (chrec), op, NULL);
Index: gcc/tree-inline.c
===================================================================
--- gcc.orig/tree-inline.c	2009-09-28 13:26:31.000000000 +0200
+++ gcc/tree-inline.c	2009-09-29 15:33:55.000000000 +0200
@@ -1505,7 +1505,7 @@  copy_bb (copy_body_data *id, basic_block
       /* With return slot optimization we can end up with
 	 non-gimple (foo *)&this->m, fix that here.  */
       if (is_gimple_assign (stmt)
-	  && gimple_assign_rhs_code (stmt) == NOP_EXPR
+	  && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
 	  && !is_gimple_val (gimple_assign_rhs1 (stmt)))
 	{
 	  tree new_rhs;
Index: gcc/tree-pretty-print.c
===================================================================
--- gcc.orig/tree-pretty-print.c	2009-09-15 15:02:55.000000000 +0200
+++ gcc/tree-pretty-print.c	2009-09-29 15:34:52.000000000 +0200
@@ -196,7 +196,7 @@  dump_decl_name (pretty_printer *buffer,
 static void
 dump_function_name (pretty_printer *buffer, tree node, int flags)
 {
-  if (TREE_CODE (node) == NOP_EXPR)
+  if (CONVERT_EXPR_P (node))
     node = TREE_OPERAND (node, 0);
   if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
     pp_string (buffer, lang_hooks.decl_printable_name (node, 1));
@@ -2679,7 +2679,7 @@  print_call_name (pretty_printer *buffer,
 
     case ADDR_EXPR:
     case INDIRECT_REF:
-    case NOP_EXPR:
+    CASE_CONVERT:
       op0 = TREE_OPERAND (op0, 0);
       goto again;
 
Index: gcc/tree-sra.c
===================================================================
--- gcc.orig/tree-sra.c	2009-09-20 22:05:01.000000000 +0200
+++ gcc/tree-sra.c	2009-09-29 15:35:22.000000000 +0200
@@ -3517,7 +3517,7 @@  sra_ipa_modify_expr (tree *expr, gimple_
       || TREE_CODE (*expr) == IMAGPART_EXPR
       || TREE_CODE (*expr) == REALPART_EXPR)
     expr = &TREE_OPERAND (*expr, 0);
-  while (TREE_CODE (*expr) == NOP_EXPR
+  while (CONVERT_EXPR_P (*expr)
 	 || TREE_CODE (*expr) == VIEW_CONVERT_EXPR)
     expr = &TREE_OPERAND (*expr, 0);
 
Index: gcc/tree-ssa-forwprop.c
===================================================================
--- gcc.orig/tree-ssa-forwprop.c	2009-09-26 00:47:05.000000000 +0200
+++ gcc/tree-ssa-forwprop.c	2009-09-29 15:36:06.000000000 +0200
@@ -1167,7 +1167,7 @@  simplify_gimple_switch (gimple stmt)
       def_stmt = SSA_NAME_DEF_STMT (cond);
       if (is_gimple_assign (def_stmt))
 	{
-	  if (gimple_assign_rhs_code (def_stmt) == NOP_EXPR)
+	  if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
 	    {
 	      int need_precision;
 	      bool fail;
Index: gcc/tree-ssa-math-opts.c
===================================================================
--- gcc.orig/tree-ssa-math-opts.c	2009-07-01 12:56:16.000000000 +0200
+++ gcc/tree-ssa-math-opts.c	2009-09-29 15:36:39.000000000 +0200
@@ -993,8 +993,7 @@  find_bswap_1 (gimple stmt, struct symbol
 	  && code != RSHIFT_EXPR
 	  && code != LROTATE_EXPR
 	  && code != RROTATE_EXPR
-	  && code != NOP_EXPR
-	  && code != CONVERT_EXPR)
+	  && !CONVERT_EXPR_CODE_P (code))
 	return NULL_TREE;
 
       source_expr1 = find_bswap_1 (rhs1_stmt, n, limit - 1);
Index: gcc/tree-ssa-pre.c
===================================================================
--- gcc.orig/tree-ssa-pre.c	2009-09-15 15:02:55.000000000 +0200
+++ gcc/tree-ssa-pre.c	2009-09-29 15:37:22.000000000 +0200
@@ -1227,7 +1227,7 @@  do_unary:
 					       arg0->op0,
 					       arg1 ? arg1->op0 : NULL);
 		if (folded
-		    && TREE_CODE (folded) == NOP_EXPR)
+		    && CONVERT_EXPR_P (folded))
 		  folded = TREE_OPERAND (folded, 0);
 		if (folded
 		    && is_gimple_min_invariant (folded))
Index: gcc/tree-vect-generic.c
===================================================================
--- gcc.orig/tree-vect-generic.c	2009-07-01 12:56:16.000000000 +0200
+++ gcc/tree-vect-generic.c	2009-09-29 15:37:56.000000000 +0200
@@ -417,14 +417,12 @@  expand_vector_operations_1 (gimple_stmt_
   if (TREE_CODE (type) != VECTOR_TYPE)
     return;
 
-  if (code == NOP_EXPR 
+  if (CONVERT_EXPR_CODE_P (code)
       || code == FLOAT_EXPR
       || code == FIX_TRUNC_EXPR
       || code == VIEW_CONVERT_EXPR)
     return;
   
-  gcc_assert (code != CONVERT_EXPR);
-
   /* The signedness is determined from input argument.  */
   if (code == VEC_UNPACK_FLOAT_HI_EXPR
       || code == VEC_UNPACK_FLOAT_LO_EXPR)
Index: gcc/tree-vect-patterns.c
===================================================================
--- gcc.orig/tree-vect-patterns.c	2009-08-19 09:04:09.000000000 +0200
+++ gcc/tree-vect-patterns.c	2009-09-29 15:38:21.000000000 +0200
@@ -91,7 +91,7 @@  widened_name_p (tree name, gimple use_st
   if (!is_gimple_assign (*def_stmt))
     return false;
 
-  if (gimple_assign_rhs_code (*def_stmt) != NOP_EXPR)
+  if (! CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (*def_stmt)))
     return false;
 
   oprnd0 = gimple_assign_rhs1 (*def_stmt);
Index: gcc/tree-vrp.c
===================================================================
--- gcc.orig/tree-vrp.c	2009-09-24 14:54:13.000000000 +0200
+++ gcc/tree-vrp.c	2009-09-29 15:41:01.000000000 +0200
@@ -1399,7 +1399,7 @@  extract_range_from_assert (value_range_t
   /* Find VAR in the ASSERT_EXPR conditional.  */
   if (var == TREE_OPERAND (cond, 0)
       || TREE_CODE (TREE_OPERAND (cond, 0)) == PLUS_EXPR
-      || TREE_CODE (TREE_OPERAND (cond, 0)) == NOP_EXPR)
+      || CONVERT_EXPR_P (TREE_OPERAND (cond, 0)))
     {
       /* If the predicate is of the form VAR COMP LIMIT, then we just
 	 take LIMIT from the RHS and use the same comparison code.  */
@@ -1461,7 +1461,7 @@  extract_range_from_assert (value_range_t
      as well build the range [b_4, +INF] for it.
      One special case we handle is extracting a range from a
      range test encoded as (unsigned)var + CST <= limit.  */
-  if (TREE_CODE (cond) == NOP_EXPR
+  if (CONVERT_EXPR_P (cond)
       || TREE_CODE (cond) == PLUS_EXPR)
     {
       if (TREE_CODE (cond) == PLUS_EXPR)
@@ -4680,7 +4680,8 @@  find_assert_locations_1 (basic_block bb,
 		  gimple def_stmt = SSA_NAME_DEF_STMT (t);
 	
 		  while (is_gimple_assign (def_stmt)
-			 && gimple_assign_rhs_code (def_stmt)  == NOP_EXPR
+			 && CONVERT_EXPR_CODE_P
+			     (gimple_assign_rhs_code (def_stmt))
 			 && TREE_CODE
 			     (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
 			 && POINTER_TYPE_P
Index: gcc/tree.c
===================================================================
--- gcc.orig/tree.c	2009-09-28 17:47:20.000000000 +0200
+++ gcc/tree.c	2009-09-29 15:45:30.000000000 +0200
@@ -3547,7 +3547,7 @@  build1_stat (enum tree_code code, tree t
 #endif
   tree t;
 
-  if (code == CONVERT_EXPR)
+  if (0 && code == CONVERT_EXPR)
     code = NOP_EXPR;
 
 #ifdef GATHER_STATISTICS
@@ -7593,7 +7593,7 @@  get_narrower (tree op, int *unsignedp_pt
   tree win = op;
   int typekind = kind_of_type (TREE_TYPE (op));
 
-  while (TREE_CODE (op) == NOP_EXPR)
+  while (CONVERT_EXPR_P (op))
     {
       int bitschange
 	= (TYPE_PRECISION (TREE_TYPE (op))
Index: gcc/varasm.c
===================================================================
--- gcc.orig/varasm.c	2009-09-24 14:54:14.000000000 +0200
+++ gcc/varasm.c	2009-09-29 15:42:00.000000000 +0200
@@ -4449,7 +4449,7 @@  output_constant (tree exp, unsigned HOST
      to the address of some declaration somewhere.  If the target says
      the mode is valid for pointers, assume the target has a way of
      resolving it.  */
-  if (TREE_CODE (exp) == NOP_EXPR
+  if (CONVERT_EXPR_P (exp)
       && POINTER_TYPE_P (TREE_TYPE (exp))
       && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
     {
@@ -4457,7 +4457,7 @@  output_constant (tree exp, unsigned HOST
 
       /* Peel off any intermediate conversions-to-pointer for valid
 	 pointer modes.  */
-      while (TREE_CODE (exp) == NOP_EXPR
+      while (CONVERT_EXPR_P (exp)
 	     && POINTER_TYPE_P (TREE_TYPE (exp))
 	     && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
 	exp = TREE_OPERAND (exp, 0);