Attachment 'clip-patch-against-gcc-4.1.0-release.patch'

Download

   1 Index: gcc/tree-pretty-print.c
   2 ===================================================================
   3 --- gcc/tree-pretty-print.c	(revision 113759)
   4 +++ gcc/tree-pretty-print.c	(working copy)
   5 @@ -1158,6 +1158,14 @@
   6        pp_character (buffer, '>');
   7        break;
   8  
   9 +    case CLIP_EXPR:
  10 +      pp_string (buffer, "CLIP_EXPR <");
  11 +      dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
  12 +      pp_string (buffer, ", ");
  13 +      dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
  14 +      pp_character (buffer, '>');
  15 +      break;
  16 +
  17      case ABS_EXPR:
  18        pp_string (buffer, "ABS_EXPR <");
  19        dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
  20 Index: gcc/optabs.c
  21 ===================================================================
  22 --- gcc/optabs.c	(revision 113759)
  23 +++ gcc/optabs.c	(working copy)
  24 @@ -291,6 +291,9 @@
  25      case MIN_EXPR:
  26        return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
  27  
  28 +    case CLIP_EXPR:
  29 +      return TYPE_UNSIGNED (type) ? uclip_optab : sclip_optab;
  30 +
  31      case REALIGN_LOAD_EXPR:
  32        return vec_realign_load_optab;
  33  
  34 @@ -5028,8 +5031,10 @@
  35    rotr_optab = init_optab (ROTATERT);
  36    smin_optab = init_optab (SMIN);
  37    smax_optab = init_optab (SMAX);
  38 +  sclip_optab = init_optab (SCLIP);
  39    umin_optab = init_optab (UMIN);
  40    umax_optab = init_optab (UMAX);
  41 +  uclip_optab = init_optab (UCLIP);
  42    pow_optab = init_optab (UNKNOWN);
  43    atan2_optab = init_optab (UNKNOWN);
  44  
  45 @@ -5194,10 +5199,12 @@
  46    init_integral_libfuncs (lshr_optab, "lshr", '3');
  47    init_integral_libfuncs (smin_optab, "min", '3');
  48    init_floating_libfuncs (smin_optab, "min", '3');
  49 +  init_integral_libfuncs (sclip_optab, "clip", '3');
  50    init_integral_libfuncs (smax_optab, "max", '3');
  51    init_floating_libfuncs (smax_optab, "max", '3');
  52    init_integral_libfuncs (umin_optab, "umin", '3');
  53    init_integral_libfuncs (umax_optab, "umax", '3');
  54 +  init_integral_libfuncs (uclip_optab, "uclip", '3');
  55    init_integral_libfuncs (neg_optab, "neg", '2');
  56    init_floating_libfuncs (neg_optab, "neg", '2');
  57    init_integral_libfuncs (negv_optab, "negv", '2');
  58 Index: gcc/optabs.h
  59 ===================================================================
  60 --- gcc/optabs.h	(revision 113759)
  61 +++ gcc/optabs.h	(working copy)
  62 @@ -120,10 +120,14 @@
  63    OTI_smin,
  64    /* Signed and floating-point maximum value */
  65    OTI_smax,
  66 +  /* Signed clip to range [-N-1 .. N] */
  67 +  OTI_sclip,
  68    /* Unsigned minimum value */
  69    OTI_umin,
  70    /* Unsigned maximum value */
  71    OTI_umax,
  72 +  /* Unsigned clip to range [zero .. N] */
  73 +  OTI_uclip,
  74    /* Power */
  75    OTI_pow,
  76    /* Arc tangent of y/x */
  77 @@ -289,8 +293,10 @@
  78  #define rotr_optab (optab_table[OTI_rotr])
  79  #define smin_optab (optab_table[OTI_smin])
  80  #define smax_optab (optab_table[OTI_smax])
  81 +#define sclip_optab (optab_table[OTI_sclip])
  82  #define umin_optab (optab_table[OTI_umin])
  83  #define umax_optab (optab_table[OTI_umax])
  84 +#define uclip_optab (optab_table[OTI_uclip])
  85  #define pow_optab (optab_table[OTI_pow])
  86  #define atan2_optab (optab_table[OTI_atan2])
  87  
  88 Index: gcc/genopinit.c
  89 ===================================================================
  90 --- gcc/genopinit.c	(revision 113759)
  91 +++ gcc/genopinit.c	(working copy)
  92 @@ -104,8 +104,10 @@
  93    "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
  94    "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$a3$)",
  95    "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$a3$)",
  96 +  "sclip_optab->handlers[$A].insn_code = CODE_FOR_$(sclip$a3$)",
  97    "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
  98    "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
  99 +  "uclip_optab->handlers[$A].insn_code = CODE_FOR_$(uclip$a3$)",
 100    "pow_optab->handlers[$A].insn_code = CODE_FOR_$(pow$a3$)",
 101    "atan2_optab->handlers[$A].insn_code = CODE_FOR_$(atan2$a3$)",
 102    "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
 103 Index: gcc/fold-const.c
 104 ===================================================================
 105 --- gcc/fold-const.c	(revision 113759)
 106 +++ gcc/fold-const.c	(working copy)
 107 @@ -4376,6 +4376,113 @@
 108  	break;
 109        }
 110  
 111 +  /* Try transforming A op B ? A : MIN|MAX(B,C); limited to integers.
 112 +     The rules are
 113 +
 114 +     A <= B ? A : MAX(B,C) is CLIP(B, [C..A])
 115 +     A < B  ? A : MAX(B,C) is CLIP(B, [C..A])
 116 +     A > B  ? A : MIN(B,C) is CLIP(B, [A..C])
 117 +     A >= B ? A : MIN(B,C) is CLIP(B, [A..C]).
 118 +
 119 +     Perform folding only if either
 120 +      - lower bound of range is 0 and the CLIP_EXPR has unsigned type
 121 +      - the clipping range is the interval [~N..N] and CLIP_EXPR has signed type.
 122 +  */
 123 +
 124 +  /* Folding is done in prefix (depth-first) mode: look for MIN/MAX in either branch
 125 +     of COND_EXPR */
 126 +  if (INTEGRAL_TYPE_P (arg1_type) && INTEGRAL_TYPE_P (TREE_TYPE (arg2))
 127 +      && (((comp_code == LT_EXPR || comp_code == LE_EXPR)
 128 +	   && (TREE_CODE (arg1) == MAX_EXPR || TREE_CODE (arg2) == MAX_EXPR))
 129 +	  || 
 130 +	  ((comp_code == GT_EXPR || comp_code == GE_EXPR)
 131 +	   && (TREE_CODE (arg1) == MIN_EXPR || TREE_CODE (arg2) == MIN_EXPR))))
 132 +    { /* MIN (MAX (a,b),upper) or MAX (MIN (a,b), lower): identify which of the
 133 +	 two operands of the inner folded op could be the actual variable to be CLIPped
 134 +
 135 +	 Both MIN and MAX are commutative - try both permutations of each.
 136 +      */
 137 +      int arg1_nested = (TREE_CODE (arg1) == MIN_EXPR || TREE_CODE (arg1) == MAX_EXPR);
 138 +      tree minmax = (arg1_nested ? arg1 : arg2);
 139 +      tree simple_arg = (arg1_nested ? arg2 : arg1);
 140 +      tree minmax_opd0 = TREE_OPERAND (minmax, 0);
 141 +      tree minmax_opd1 = TREE_OPERAND (minmax, 1);
 142 +      int inner_is_max = (TREE_CODE (minmax) == MAX_EXPR);
 143 +      tree clipped = NULL_TREE,
 144 +	lower = (inner_is_max ? NULL_TREE : simple_arg),
 145 +	upper = (inner_is_max ? simple_arg : NULL_TREE);
 146 +      tree result_type;
 147 +
 148 +      STRIP_NOPS (simple_arg);
 149 +      STRIP_NOPS (minmax_opd0);
 150 +      STRIP_NOPS (minmax_opd1);
 151 +
 152 +      if (!inner_is_max && integer_zerop (lower))
 153 +	/* lower bound is zero: possible UCLIP, clip base is other arg of compare */
 154 +	{
 155 +	  clipped = (TREE_CODE (arg00) == INTEGER_CST ? arg01 : arg00);
 156 +	  upper = (operand_equal_for_comparison_p (clipped, minmax_opd0, minmax_opd1)?
 157 +		   minmax_opd1 : minmax_opd0);
 158 +	}
 159 +      else if (integer_zerop (minmax_opd0))
 160 +	{ /* clip base is minmax_opd1 */
 161 +	  clipped = minmax_opd1;
 162 +	  if (inner_is_max)
 163 +	    lower = minmax_opd0;
 164 +	  else
 165 +	    upper = minmax_opd0;
 166 +	}
 167 +      else if (integer_zerop (minmax_opd1))
 168 +	{ /* clip base is minmax_opd0 */
 169 +	  clipped = minmax_opd0;
 170 +	  if (inner_is_max)
 171 +	    lower = minmax_opd1;
 172 +	  else
 173 +	    upper = minmax_opd1;
 174 +	}
 175 +      else
 176 +	{ /* try -N - 1 .. N */
 177 +	  tree expected_other_bound =
 178 +	    negate_expr (fold_build2 (PLUS_EXPR, TREE_TYPE (simple_arg),
 179 +				      simple_arg, integer_one_node));
 180 +
 181 +	  if (operand_equal_p (expected_other_bound, minmax_opd0, 0))
 182 +	    {
 183 +	      clipped = minmax_opd1;
 184 +	      if (inner_is_max)
 185 +		lower = minmax_opd0;
 186 +	      else
 187 +		upper = minmax_opd0;
 188 +	  }
 189 +	  else if (operand_equal_p (expected_other_bound, minmax_opd1, 0))
 190 +	    {
 191 +	      clipped = minmax_opd0;
 192 +	      if (inner_is_max)
 193 +		lower = minmax_opd1;
 194 +	      else
 195 +		upper = minmax_opd1;
 196 +	    }
 197 +	}
 198 +
 199 +      if (clipped != NULL_TREE && lower != NULL_TREE && upper != NULL_TREE)
 200 +	{
 201 +	  STRIP_NOPS (clipped);
 202 +	  STRIP_NOPS (upper);
 203 +
 204 +	  /* result is unsigned if range is 0..N */
 205 +	  result_type = (integer_zerop (lower) ?
 206 +			 lang_hooks.types.unsigned_type (TREE_TYPE (clipped)) :
 207 +			 lang_hooks.types.signed_type (TREE_TYPE (clipped)));
 208 +	  
 209 +	  /* fold only if doing so is safe */	  
 210 +          if ((TYPE_UNSIGNED (type) && integer_zerop (lower))
 211 +	      || ( !TYPE_UNSIGNED (type)
 212 +		   && !TYPE_UNSIGNED (TREE_TYPE (clipped))
 213 +		   && !TYPE_UNSIGNED (TREE_TYPE (upper))))
 214 +	  return pedantic_non_lvalue (fold_build2 (CLIP_EXPR, result_type, clipped, upper));
 215 +	}
 216 +    }	    
 217 +
 218    /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
 219       A == 0 ? A : 0 is always 0 unless A is -0.  Note that
 220       both transformations are correct when A is NaN: A != 0
 221 @@ -9933,6 +10040,47 @@
 222    return (walk_tree (&st, contains_label_1 , NULL, NULL) != NULL_TREE);
 223  }
 224  
 225 +/* Build a comparison expression which is the mirror form of the original,
 226 +   e.g., convert A <= B into B => A. Do not perform folding on operands.
 227 +
 228 +   This transformation is invalid if either argument contains side effects
 229 +   which may interfere with the evaluation of the other one. */
 230 +
 231 +/* helper function: get the mirror of the relational operator in tree code */
 232 +static enum tree_code
 233 +get_mirror_compare_op (enum tree_code code)
 234 +{
 235 +  switch (code) {
 236 +  case LT_EXPR: return GT_EXPR;
 237 +  case LE_EXPR: return GE_EXPR;
 238 +  case GT_EXPR: return LT_EXPR;
 239 +  case GE_EXPR: return LE_EXPR;
 240 +
 241 +  case UNLT_EXPR: return UNGT_EXPR;
 242 +  case UNLE_EXPR: return UNGE_EXPR;
 243 +  case UNGT_EXPR: return UNLT_EXPR;
 244 +  case UNGE_EXPR: return UNLE_EXPR;
 245 +
 246 +  case EQ_EXPR:
 247 +  case NE_EXPR:
 248 +  case UNEQ_EXPR:
 249 +    return code;
 250 +  default:
 251 +    gcc_unreachable();
 252 +  }
 253 +}
 254 +
 255 +static tree
 256 +make_mirror_compare (tree comp)
 257 +{
 258 +  tree opd0 = TREE_OPERAND (comp, 0);
 259 +  tree opd1 = TREE_OPERAND (comp, 1);
 260 +  enum tree_code code = TREE_CODE (comp);
 261 +
 262 +  gcc_assert (COMPARISON_CLASS_P (comp));
 263 +  return build2 (get_mirror_compare_op (code), TREE_TYPE (comp), opd1, opd0);
 264 +}
 265 +
 266  /* Fold a ternary expression of code CODE and type TYPE with operands
 267     OP0, OP1, and OP2.  Return the folded expression if folding is
 268     successful.  Otherwise, return NULL_TREE.  */
 269 @@ -9941,7 +10089,7 @@
 270  fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
 271  {
 272    tree tem;
 273 -  tree arg0 = NULL_TREE, arg1 = NULL_TREE;
 274 +  tree arg0 = NULL_TREE, arg1 = NULL_TREE, arg2 = NULL_TREE;
 275    enum tree_code_class kind = TREE_CODE_CLASS (code);
 276  
 277    gcc_assert (IS_EXPR_CODE_CLASS (kind)
 278 @@ -9968,6 +10116,11 @@
 279        arg1 = op1;
 280        STRIP_NOPS (arg1);
 281      }
 282 +  if (op2)
 283 +    {
 284 +      arg2 = op2;
 285 +      STRIP_NOPS (arg2);
 286 +    }
 287  
 288    switch (code)
 289      {
 290 @@ -10009,7 +10162,8 @@
 291  	 of B and C.  Signed zeros prevent all of these transformations,
 292  	 for reasons given above each one.
 293  
 294 -         Also try swapping the arguments and inverting the conditional.  */
 295 +         Also try swapping the arguments (arg1 with arg2, and in the comparison),
 296 +	 and inverting the conditional.  */
 297        if (COMPARISON_CLASS_P (arg0)
 298  	  && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
 299  					     arg1, TREE_OPERAND (arg0, 1))
 300 @@ -10021,10 +10175,21 @@
 301  	}
 302  
 303        if (COMPARISON_CLASS_P (arg0)
 304 +	  && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
 305 +					     arg1, TREE_OPERAND (arg0, 0))
 306 +	  && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
 307 +	{
 308 +	  tem = fold_cond_expr_with_comparison (type, make_mirror_compare (arg0),
 309 +						op1, op2);
 310 +	  if (tem)
 311 +	    return tem;
 312 +	}
 313 +
 314 +      if (COMPARISON_CLASS_P (arg0)
 315  	  && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
 316 -					     op2,
 317 +					     arg2,
 318  					     TREE_OPERAND (arg0, 1))
 319 -	  && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
 320 +	  && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg2))))
 321  	{
 322  	  tem = invert_truthvalue (arg0);
 323  	  if (COMPARISON_CLASS_P (tem))
 324 @@ -10035,6 +10200,22 @@
 325  	    }
 326  	}
 327  
 328 +      if (COMPARISON_CLASS_P (arg0)
 329 +	  && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
 330 +					     arg2,
 331 +					     TREE_OPERAND (arg0, 0))
 332 +	  && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg2))))
 333 +	{
 334 +	  tem = invert_truthvalue (arg0);
 335 +	  if (COMPARISON_CLASS_P (tem))
 336 +	    {
 337 +	      tem = fold_cond_expr_with_comparison (type, make_mirror_compare (tem),
 338 +						    op2, op1);
 339 +	      if (tem)
 340 +		return tem;
 341 +	    }
 342 +	}
 343 +
 344        /* If the second operand is simpler than the third, swap them
 345  	 since that produces better jump optimization results.  */
 346        if (truth_value_p (TREE_CODE (arg0))
 347 Index: gcc/rtl.def
 348 ===================================================================
 349 --- gcc/rtl.def	(revision 113759)
 350 +++ gcc/rtl.def	(working copy)
 351 @@ -469,6 +469,15 @@
 352  DEF_RTL_EXPR(UMIN, "umin", "ee", RTX_COMM_ARITH)
 353  DEF_RTL_EXPR(UMAX, "umax", "ee", RTX_COMM_ARITH)
 354  
 355 +/* Clipping of operand 0 to signed/unsigned range, inclusive.
 356 +
 357 +   The signed range is [-opd1 - 1 .. opd1], whereas the unsigned range
 358 +   is 0 .. opd1.  Neither flavour of the operator is commutative, so the
 359 +   RTXes belong to the RTX_BIN_ARITH class. */
 360 +
 361 +DEF_RTL_EXPR(SCLIP, "sclip", "ee", RTX_BIN_ARITH)
 362 +DEF_RTL_EXPR(UCLIP, "uclip", "ee", RTX_BIN_ARITH)
 363 +
 364  /* These unary operations are used to represent incrementation
 365     and decrementation as they occur in memory addresses.
 366     The amount of increment or decrement are not represented
 367 Index: gcc/expr.c
 368 ===================================================================
 369 --- gcc/expr.c	(revision 113759)
 370 +++ gcc/expr.c	(working copy)
 371 @@ -8142,6 +8142,77 @@
 372        emit_label (temp);
 373        return target;
 374  
 375 +    case CLIP_EXPR:
 376 +      target = original_target;
 377 +      if (target == 0
 378 +	  || modifier == EXPAND_STACK_PARM
 379 +	  || (MEM_P (target) && MEM_VOLATILE_P (target))
 380 +	  || GET_MODE (target) != mode
 381 +	  || (REG_P (target)
 382 +	      && REGNO (target) < FIRST_PSEUDO_REGISTER))
 383 +	target = gen_reg_rtx (mode);
 384 +      expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
 385 +		       target, &op0, &op1, 0);
 386 +
 387 +      /* First try to do it with a special CLIP instruction.
 388 +	 If that does not win, revert to MIN (MAX ()) construction
 389 +	 to select the proper value.  */
 390 +      this_optab = optab_for_tree_code (code, type);
 391 +      temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
 392 +			   OPTAB_WIDEN);
 393 +      if (temp != 0)
 394 +	return temp;
 395 +
 396 +      /* At this point, a MEM target is no longer useful; we will get better
 397 +	 code without it.  */
 398 +
 399 +      if (! REG_P (target))
 400 +	target = gen_reg_rtx (mode);
 401 +
 402 +      /* If op1 was placed in target, swap op0 and op1.  */
 403 +      if (target != op0 && target == op1)
 404 +	{
 405 +	  temp = op0;
 406 +	  op0 = op1;
 407 +	  op1 = temp;
 408 +	}
 409 +
 410 +      /* We generate better code and avoid problems with op1 mentioning
 411 +	 target by forcing op1 into a pseudo if it isn't a constant.  */
 412 +      if (! CONSTANT_P (op1))
 413 +	op1 = force_reg (mode, op1);
 414 +
 415 +      {
 416 +	tree tree_opd0 = TREE_OPERAND (exp, 0);
 417 +	tree tree_opd1 = TREE_OPERAND (exp, 1);
 418 +
 419 +	if (TYPE_UNSIGNED (type))
 420 +	  /* clip to 0..opd1 === MIN(MAX(opd0, 0),opd1) */
 421 +	  return
 422 +	    expand_expr (build2 (MIN_EXPR, type,
 423 +				 build2 (MAX_EXPR, TREE_TYPE (tree_opd0),
 424 +					 tree_opd0,
 425 +					 fold_convert (type,
 426 +						       integer_zero_node)),
 427 +				 tree_opd1),
 428 +			 target, mode, 0);
 429 +	else
 430 +	  /* clip to -opd1-1 .. opd1 === MIN(MAX(opd0, -opd1-1), opd1) */
 431 +	  return
 432 +	    expand_expr
 433 +	    (build2 (MIN_EXPR, type,
 434 +		     build2 (MAX_EXPR, TREE_TYPE (tree_opd0),
 435 +			     tree_opd0,
 436 +			     fold_build1 (NEGATE_EXPR,
 437 +					  TREE_TYPE (tree_opd1),
 438 +					  fold_build2 (PLUS_EXPR,
 439 +						       TREE_TYPE (tree_opd1),
 440 +						       tree_opd1,
 441 +						       integer_one_node))),
 442 +		     tree_opd1),
 443 +	     target, mode, 0);
 444 +      }
 445 +      
 446      case BIT_NOT_EXPR:
 447        op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
 448        if (modifier == EXPAND_STACK_PARM)
 449 Index: gcc/tree.def
 450 ===================================================================
 451 --- gcc/tree.def	(revision 113759)
 452 +++ gcc/tree.def	(working copy)
 453 @@ -654,6 +654,16 @@
 454  DEFTREECODE (MIN_EXPR, "min_expr", tcc_binary, 2)
 455  DEFTREECODE (MAX_EXPR, "max_expr", tcc_binary, 2)
 456  
 457 +/* Clip arg1 to a signed (resp. unsigned) range, inclusive.
 458 +
 459 +   Signed range is [ -arg2 - 1 .. arg2 ], whereas
 460 +   the unsigned range is [ 0 .. arg2 ].  The signedness of the range
 461 +   is determined by the type of the result.
 462 +
 463 +   Both arguments and the CLIP_EXPR must have an INTEGER_TYPE.
 464 +*/
 465 +DEFTREECODE (CLIP_EXPR, "clip_expr", tcc_binary, 2) 
 466 +
 467  /* Represents the absolute value of the operand.
 468  
 469     An ABS_EXPR must have either an INTEGER_TYPE or a REAL_TYPE.  The
 470 Index: gcc/simplify-rtx.c
 471 ===================================================================
 472 --- gcc/simplify-rtx.c	(revision 113759)
 473 +++ gcc/simplify-rtx.c	(working copy)
 474 @@ -1956,6 +1956,11 @@
 475  	return tem;
 476        break;
 477  
 478 +    case SCLIP:
 479 +    case UCLIP:
 480 +      /* could we optimize any further? */
 481 +      return 0;
 482 +
 483      case SS_PLUS:
 484      case US_PLUS:
 485      case SS_MINUS:
 486 Index: gcc/explow.c
 487 ===================================================================
 488 --- gcc/explow.c	(revision 113759)
 489 +++ gcc/explow.c	(working copy)
 490 @@ -1480,6 +1480,10 @@
 491      case SMAX:
 492        tcode = MAX_EXPR;
 493        break;
 494 +    case SCLIP:
 495 +    case UCLIP:
 496 +      tcode = CLIP_EXPR;
 497 +      break;
 498      default:
 499        tcode = LAST_AND_UNUSED_TREE_CODE;
 500        break;
 501 Index: gcc/tree-inline.c
 502 ===================================================================
 503 --- gcc/tree-inline.c	(revision 113759)
 504 +++ gcc/tree-inline.c	(working copy)
 505 @@ -1754,6 +1754,7 @@
 506      case FLOAT_EXPR:
 507      case MIN_EXPR:
 508      case MAX_EXPR:
 509 +    case CLIP_EXPR:
 510      case ABS_EXPR:
 511  
 512      case LSHIFT_EXPR:
 513 Index: gcc/c-common.c
 514 ===================================================================
 515 --- gcc/c-common.c	(revision 113759)
 516 +++ gcc/c-common.c	(working copy)
 517 @@ -1886,6 +1886,8 @@
 518        opname = "max"; break;
 519      case MIN_EXPR:
 520        opname = "min"; break;
 521 +    case CLIP_EXPR:
 522 +      opname = "clip"; break;
 523      case EQ_EXPR:
 524        opname = "=="; break;
 525      case NE_EXPR:

Attached Files

To refer to attachments on a page, use attachment:filename, as shown below in the list of files. Do NOT use the URL of the [get] link, since this is subject to change and can break easily.

You are not allowed to attach a file to this page.