gcc/match.pd

   1 /* Match-and-simplify patterns for shared GENERIC and GIMPLE folding.
   2    This file is consumed by genmatch which produces gimple-match.c
   3    and generic-match.c from it.
   4
   5    Copyright (C) 2014 Free Software Foundation, Inc.
   6    Contributed by Richard Biener <rguenther@suse.de>
   7    and Prathamesh Kulkarni  <bilbotheelffriend@gmail.com>
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify it under
  12 the terms of the GNU General Public License as published by the Free
  13 Software Foundation; either version 3, or (at your option) any later
  14 version.
  15
  16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19 for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25
  26 /* Generic tree predicates we inherit.  */
  27 (define_predicates
  28    integer_onep integer_zerop integer_all_onesp integer_minus_onep
  29    integer_each_onep integer_truep
  30    real_zerop real_onep real_minus_onep
  31    CONSTANT_CLASS_P
  32    tree_expr_nonnegative_p)
  33
  34 /* Operator lists.  */
  35 (define_operator_list tcc_comparison
  36   lt   le   eq ne ge   gt   unordered ordered   unlt unle ungt unge uneq ltgt)
  37 (define_operator_list inverted_tcc_comparison
  38   ge   gt   ne eq lt   le   ordered   unordered ge   gt   le   lt   ltgt uneq)
  39 (define_operator_list inverted_tcc_comparison_with_nans
  40   unge ungt ne eq unlt unle ordered   unordered ge   gt   le   lt   ltgt uneq)
  41
  42
  43 /* Simplifications of operations with one constant operand and
  44    simplifications to constants or single values.  */
  45
  46 (for op (plus pointer_plus minus bit_ior bit_xor)
  47   (simplify
  48     (op @0 integer_zerop)
  49     (non_lvalue @0)))
  50
  51 /* 0 +p index -> (type)index */
  52 (simplify
  53  (pointer_plus integer_zerop @1)
  54  (non_lvalue (convert @1)))
  55
  56 /* See if ARG1 is zero and X + ARG1 reduces to X.
  57    Likewise if the operands are reversed.  */
  58 (simplify
  59  (plus:c @0 real_zerop@1)
  60  (if (fold_real_zero_addition_p (type, @1, 0))
  61   (non_lvalue @0)))
  62
  63 /* See if ARG1 is zero and X - ARG1 reduces to X.  */
  64 (simplify
  65  (minus @0 real_zerop@1)
  66  (if (fold_real_zero_addition_p (type, @1, 1))
  67   (non_lvalue @0)))
  68
  69 /* Simplify x - x.
  70    This is unsafe for certain floats even in non-IEEE formats.
  71    In IEEE, it is unsafe because it does wrong for NaNs.
  72    Also note that operand_equal_p is always false if an operand
  73    is volatile.  */
  74 (simplify
  75  (minus @0 @0)
  76  (if (!FLOAT_TYPE_P (type) || !HONOR_NANS (element_mode (type)))
  77   { build_zero_cst (type); }))
  78
  79 (simplify
  80  (mult @0 integer_zerop@1)
  81  @1)
  82
  83 /* Maybe fold x * 0 to 0.  The expressions aren't the same
  84    when x is NaN, since x * 0 is also NaN.  Nor are they the
  85    same in modes with signed zeros, since multiplying a
  86    negative value by 0 gives -0, not +0.  */
  87 (simplify
  88  (mult @0 real_zerop@1)
  89  (if (!HONOR_NANS (element_mode (type))
  90       && !HONOR_SIGNED_ZEROS (element_mode (type)))
  91   @1))
  92
  93 /* In IEEE floating point, x*1 is not equivalent to x for snans.
  94    Likewise for complex arithmetic with signed zeros.  */
  95 (simplify
  96  (mult @0 real_onep)
  97  (if (!HONOR_SNANS (element_mode (type))
  98       && (!HONOR_SIGNED_ZEROS (element_mode (type))
  99           || !COMPLEX_FLOAT_TYPE_P (type)))
 100   (non_lvalue @0)))
 101
 102 /* Transform x * -1.0 into -x.  */
 103 (simplify
 104  (mult @0 real_minus_onep)
 105   (if (!HONOR_SNANS (element_mode (type))
 106        && (!HONOR_SIGNED_ZEROS (element_mode (type))
 107            || !COMPLEX_FLOAT_TYPE_P (type)))
 108    (negate @0)))
 109
 110 /* Make sure to preserve divisions by zero.  This is the reason why
 111    we don't simplify x / x to 1 or 0 / x to 0.  */
 112 (for op (mult trunc_div ceil_div floor_div round_div exact_div)
 113   (simplify
 114     (op @0 integer_onep)
 115     (non_lvalue @0)))
 116
 117 /* X / -1 is -X.  */
 118 (for div (trunc_div ceil_div floor_div round_div exact_div)
 119  (simplify
 120    (div @0 integer_minus_onep@1)
 121    (if (!TYPE_UNSIGNED (type))
 122     (negate @0))))
 123
 124 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
 125    TRUNC_DIV_EXPR.  Rewrite into the latter in this case.  */
 126 (simplify
 127  (floor_div @0 @1)
 128  (if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
 129       && TYPE_UNSIGNED (type))
 130   (trunc_div @0 @1)))
 131
 132 /* Optimize A / A to 1.0 if we don't care about
 133    NaNs or Infinities.  */
 134 (simplify
 135  (rdiv @0 @0)
 136  (if (FLOAT_TYPE_P (type)
 137       && ! HONOR_NANS (element_mode (type))
 138       && ! HONOR_INFINITIES (element_mode (type)))
 139   { build_one_cst (type); }))
 140
 141 /* Optimize -A / A to -1.0 if we don't care about
 142    NaNs or Infinities.  */
 143 (simplify
 144  (rdiv:c @0 (negate @0))
 145  (if (FLOAT_TYPE_P (type)
 146       && ! HONOR_NANS (element_mode (type))
 147       && ! HONOR_INFINITIES (element_mode (type)))
 148   { build_minus_one_cst (type); }))
 149
 150 /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
 151 (simplify
 152  (rdiv @0 real_onep)
 153  (if (!HONOR_SNANS (element_mode (type)))
 154   (non_lvalue @0)))
 155
 156 /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
 157 (simplify
 158  (rdiv @0 real_minus_onep)
 159  (if (!HONOR_SNANS (element_mode (type)))
 160   (negate @0)))
 161
 162 /* If ARG1 is a constant, we can convert this to a multiply by the
 163    reciprocal.  This does not have the same rounding properties,
 164    so only do this if -freciprocal-math.  We can actually
 165    always safely do it if ARG1 is a power of two, but it's hard to
 166    tell if it is or not in a portable manner.  */
 167 (for cst (REAL_CST COMPLEX_CST VECTOR_CST)
 168  (simplify
 169   (rdiv @0 cst@1)
 170   (if (optimize)
 171    (if (flag_reciprocal_math
 172         && !real_zerop (@1))
 173     (with
 174      { tree tem = fold_binary (RDIV_EXPR, type, build_one_cst (type), @1); }
 175      (if (tem)
 176       (mult @0 { tem; } ))))
 177    (if (cst != COMPLEX_CST)
 178     (with { tree inverse = exact_inverse (type, @1); }
 179      (if (inverse)
 180       (mult @0 { inverse; } )))))))
 181
 182 /* Same applies to modulo operations, but fold is inconsistent here
 183    and simplifies 0 % x to 0, only preserving literal 0 % 0.  */
 184 (for mod (ceil_mod floor_mod round_mod trunc_mod)
 185  /* 0 % X is always zero.  */
 186  (simplify
 187   (mod integer_zerop@0 @1)
 188   /* But not for 0 % 0 so that we can get the proper warnings and errors.  */
 189   (if (!integer_zerop (@1))
 190    @0))
 191  /* X % 1 is always zero.  */
 192  (simplify
 193   (mod @0 integer_onep)
 194   { build_zero_cst (type); })
 195  /* X % -1 is zero.  */
 196  (simplify
 197   (mod @0 integer_minus_onep@1)
 198   (if (!TYPE_UNSIGNED (type))
 199    { build_zero_cst (type); })))
 200
 201 /* X % -C is the same as X % C.  */
 202 (simplify
 203  (trunc_mod @0 INTEGER_CST@1)
 204   (if (TYPE_SIGN (type) == SIGNED
 205        && !TREE_OVERFLOW (@1)
 206        && wi::neg_p (@1)
 207        && !TYPE_OVERFLOW_TRAPS (type)
 208        /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
 209        && !sign_bit_p (@1, @1))
 210    (trunc_mod @0 (negate @1))))
 211
 212 /* x | ~0 -> ~0  */
 213 (simplify
 214   (bit_ior @0 integer_all_onesp@1)
 215   @1)
 216
 217 /* x & 0 -> 0  */
 218 (simplify
 219   (bit_and @0 integer_zerop@1)
 220   @1)
 221
 222 /* x ^ x -> 0 */
 223 (simplify
 224   (bit_xor @0 @0)
 225   { build_zero_cst (type); })
 226
 227 /* Canonicalize X ^ ~0 to ~X.  */
 228 (simplify
 229   (bit_xor @0 integer_all_onesp@1)
 230   (bit_not @0))
 231
 232 /* x & ~0 -> x  */
 233 (simplify
 234  (bit_and @0 integer_all_onesp)
 235   (non_lvalue @0))
 236
 237 /* x & x -> x,  x | x -> x  */
 238 (for bitop (bit_and bit_ior)
 239  (simplify
 240   (bitop @0 @0)
 241   (non_lvalue @0)))
 242
 243 (simplify
 244  (abs (negate @0))
 245  (abs @0))
 246 (simplify
 247  (abs tree_expr_nonnegative_p@0)
 248  @0)
 249
 250
 251 /* Try to fold (type) X op CST -> (type) (X op ((type-x) CST))
 252    when profitable.
 253    For bitwise binary operations apply operand conversions to the
 254    binary operation result instead of to the operands.  This allows
 255    to combine successive conversions and bitwise binary operations.
 256    We combine the above two cases by using a conditional convert.  */
 257 (for bitop (bit_and bit_ior bit_xor)
 258  (simplify
 259   (bitop (convert @0) (convert? @1))
 260   (if (((TREE_CODE (@1) == INTEGER_CST
 261          && INTEGRAL_TYPE_P (TREE_TYPE (@0))
 262          && int_fits_type_p (@1, TREE_TYPE (@0)))
 263         || (GIMPLE && types_compatible_p (TREE_TYPE (@0), TREE_TYPE (@1)))
 264         || (GENERIC && TREE_TYPE (@0) == TREE_TYPE (@1)))
 265        /* ???  This transform conflicts with fold-const.c doing
 266           Convert (T)(x & c) into (T)x & (T)c, if c is an integer
 267           constants (if x has signed type, the sign bit cannot be set
 268           in c).  This folds extension into the BIT_AND_EXPR.
 269           Restrict it to GIMPLE to avoid endless recursions.  */
 270        && (bitop != BIT_AND_EXPR || GIMPLE)
 271        && (/* That's a good idea if the conversion widens the operand, thus
 272               after hoisting the conversion the operation will be narrower.  */
 273            TYPE_PRECISION (TREE_TYPE (@0)) < TYPE_PRECISION (type)
 274            /* It's also a good idea if the conversion is to a non-integer
 275               mode.  */
 276            || GET_MODE_CLASS (TYPE_MODE (type)) != MODE_INT
 277            /* Or if the precision of TO is not the same as the precision
 278               of its mode.  */
 279            || TYPE_PRECISION (type) != GET_MODE_PRECISION (TYPE_MODE (type))))
 280    (convert (bitop @0 (convert @1))))))
 281
 282 /* Simplify (A & B) OP0 (C & B) to (A OP0 C) & B. */
 283 (for bitop (bit_and bit_ior bit_xor)
 284  (simplify
 285   (bitop (bit_and:c @0 @1) (bit_and @2 @1))
 286   (bit_and (bitop @0 @2) @1)))
 287
 288 /* (x | CST1) & CST2 -> (x & CST2) | (CST1 & CST2) */
 289 (simplify
 290   (bit_and (bit_ior @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
 291   (bit_ior (bit_and @0 @2) (bit_and @1 @2)))
 292
 293 /* Combine successive equal operations with constants.  */
 294 (for bitop (bit_and bit_ior bit_xor)
 295  (simplify
 296   (bitop (bitop @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
 297   (bitop @0 (bitop @1 @2))))
 298
 299 /* Try simple folding for X op !X, and X op X with the help
 300    of the truth_valued_p and logical_inverted_value predicates.  */
 301 (match truth_valued_p
 302  @0
 303  (if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1)))
 304 (for op (tcc_comparison truth_and truth_andif truth_or truth_orif truth_xor)
 305  (match truth_valued_p
 306   (op @0 @1)))
 307 (match truth_valued_p
 308   (truth_not @0))
 309
 310 (match (logical_inverted_value @0)
 311  (bit_not truth_valued_p@0))
 312 (match (logical_inverted_value @0)
 313  (eq @0 integer_zerop))
 314 (match (logical_inverted_value @0)
 315  (ne truth_valued_p@0 integer_truep))
 316 (match (logical_inverted_value @0)
 317  (bit_xor truth_valued_p@0 integer_truep))
 318
 319 /* X & !X -> 0.  */
 320 (simplify
 321  (bit_and:c @0 (logical_inverted_value @0))
 322  { build_zero_cst (type); })
 323 /* X | !X and X ^ !X -> 1, , if X is truth-valued.  */
 324 (for op (bit_ior bit_xor)
 325  (simplify
 326   (op:c truth_valued_p@0 (logical_inverted_value @0))
 327   { constant_boolean_node (true, type); }))
 328
 329 (for bitop (bit_and bit_ior)
 330      rbitop (bit_ior bit_and)
 331   /* (x | y) & x -> x */
 332   /* (x & y) | x -> x */
 333  (simplify
 334   (bitop:c (rbitop:c @0 @1) @0)
 335   @0)
 336  /* (~x | y) & x -> x & y */
 337  /* (~x & y) | x -> x | y */
 338  (simplify
 339   (bitop:c (rbitop:c (bit_not @0) @1) @0)
 340   (bitop @0 @1)))
 341
 342 /* If arg1 and arg2 are booleans (or any single bit type)
 343    then try to simplify:
 344
 345    (~X & Y) -> X < Y
 346    (X & ~Y) -> Y < X
 347    (~X | Y) -> X <= Y
 348    (X | ~Y) -> Y <= X
 349
 350    But only do this if our result feeds into a comparison as
 351    this transformation is not always a win, particularly on
 352    targets with and-not instructions.
 353    -> simplify_bitwise_binary_boolean */
 354 (simplify
 355   (ne (bit_and:c (bit_not @0) @1) integer_zerop)
 356   (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
 357        && TYPE_PRECISION (TREE_TYPE (@1)) == 1)
 358    (lt @0 @1)))
 359 (simplify
 360   (ne (bit_ior:c (bit_not @0) @1) integer_zerop)
 361   (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
 362        && TYPE_PRECISION (TREE_TYPE (@1)) == 1)
 363    (le @0 @1)))
 364
 365 /* ~~x -> x */
 366 (simplify
 367   (bit_not (bit_not @0))
 368   @0)
 369
 370
 371 /* Associate (p +p off1) +p off2 as (p +p (off1 + off2)).  */
 372 (simplify
 373   (pointer_plus (pointer_plus @0 @1) @3)
 374   (pointer_plus @0 (plus @1 @3)))
 375
 376 /* Pattern match
 377      tem1 = (long) ptr1;
 378      tem2 = (long) ptr2;
 379      tem3 = tem2 - tem1;
 380      tem4 = (unsigned long) tem3;
 381      tem5 = ptr1 + tem4;
 382    and produce
 383      tem5 = ptr2;  */
 384 (simplify
 385   (pointer_plus @0 (convert?@2 (minus@3 (convert @1) (convert @0))))
 386   /* Conditionally look through a sign-changing conversion.  */
 387   (if (TYPE_PRECISION (TREE_TYPE (@2)) == TYPE_PRECISION (TREE_TYPE (@3))
 388        && ((GIMPLE && useless_type_conversion_p (type, TREE_TYPE (@1)))
 389             || (GENERIC && type == TREE_TYPE (@1))))
 390    @1))
 391
 392 /* Pattern match
 393      tem = (sizetype) ptr;
 394      tem = tem & algn;
 395      tem = -tem;
 396      ... = ptr p+ tem;
 397    and produce the simpler and easier to analyze with respect to alignment
 398      ... = ptr & ~algn;  */
 399 (simplify
 400   (pointer_plus @0 (negate (bit_and (convert @0) INTEGER_CST@1)))
 401   (with { tree algn = wide_int_to_tree (TREE_TYPE (@0), wi::bit_not (@1)); }
 402    (bit_and @0 { algn; })))
 403
 404
 405 /* We can't reassociate at all for saturating types.  */
 406 (if (!TYPE_SATURATING (type))
 407
 408  /* Contract negates.  */
 409  /* A + (-B) -> A - B */
 410  (simplify
 411   (plus:c (convert1? @0) (convert2? (negate @1)))
 412   /* Apply STRIP_NOPS on @0 and the negate.  */
 413   (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
 414        && tree_nop_conversion_p (type, TREE_TYPE (@1))
 415        && !TYPE_OVERFLOW_SANITIZED (type))
 416    (minus (convert @0) (convert @1))))
 417  /* A - (-B) -> A + B */
 418  (simplify
 419   (minus (convert1? @0) (convert2? (negate @1)))
 420   (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
 421        && tree_nop_conversion_p (type, TREE_TYPE (@1))
 422        && !TYPE_OVERFLOW_SANITIZED (type))
 423    (plus (convert @0) (convert @1))))
 424  /* -(-A) -> A */
 425  (simplify
 426   (negate (convert? (negate @1)))
 427   (if (tree_nop_conversion_p (type, TREE_TYPE (@1))
 428        && !TYPE_OVERFLOW_SANITIZED (type))
 429    (convert @1)))
 430
 431  /* We can't reassociate floating-point or fixed-point plus or minus
 432     because of saturation to +-Inf.  */
 433  (if (!FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type))
 434
 435   /* Match patterns that allow contracting a plus-minus pair
 436      irrespective of overflow issues.  */
 437   /* (A +- B) - A       ->  +- B */
 438   /* (A +- B) -+ B      ->  A */
 439   /* A - (A +- B)       -> -+ B */
 440   /* A +- (B -+ A)      ->  +- B */
 441   (simplify
 442     (minus (plus:c @0 @1) @0)
 443     @1)
 444   (simplify
 445     (minus (minus @0 @1) @0)
 446     (negate @1))
 447   (simplify
 448     (plus:c (minus @0 @1) @1)
 449     @0)
 450   (simplify
 451    (minus @0 (plus:c @0 @1))
 452    (negate @1))
 453   (simplify
 454    (minus @0 (minus @0 @1))
 455    @1)
 456
 457   /* (A +- CST) +- CST -> A + CST  */
 458   (for outer_op (plus minus)
 459    (for inner_op (plus minus)
 460     (simplify
 461      (outer_op (inner_op @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
 462      /* If the constant operation overflows we cannot do the transform
 463         as we would introduce undefined overflow, for example
 464         with (a - 1) + INT_MIN.  */
 465      (with { tree cst = fold_binary (outer_op == inner_op
 466                                      ? PLUS_EXPR : MINUS_EXPR, type, @1, @2); }
 467       (if (cst && !TREE_OVERFLOW (cst))
 468        (inner_op @0 { cst; } ))))))
 469
 470   /* (CST - A) +- CST -> CST - A  */
 471   (for outer_op (plus minus)
 472    (simplify
 473     (outer_op (minus CONSTANT_CLASS_P@1 @0) CONSTANT_CLASS_P@2)
 474     (with { tree cst = fold_binary (outer_op, type, @1, @2); }
 475      (if (cst && !TREE_OVERFLOW (cst))
 476       (minus { cst; } @0)))))
 477
 478   /* ~A + A -> -1 */
 479   (simplify
 480    (plus:c (bit_not @0) @0)
 481    (if (!TYPE_OVERFLOW_TRAPS (type))
 482     { build_all_ones_cst (type); }))
 483
 484   /* ~A + 1 -> -A */
 485   (simplify
 486    (plus (bit_not @0) integer_each_onep)
 487    (negate @0))
 488
 489   /* (T)(P + A) - (T)P -> (T) A */
 490   (for add (plus pointer_plus)
 491    (simplify
 492     (minus (convert (add @0 @1))
 493      (convert @0))
 494     (if (element_precision (type) <= element_precision (TREE_TYPE (@1))
 495          /* For integer types, if A has a smaller type
 496             than T the result depends on the possible
 497             overflow in P + A.
 498             E.g. T=size_t, A=(unsigned)429497295, P>0.
 499             However, if an overflow in P + A would cause
 500             undefined behavior, we can assume that there
 501             is no overflow.  */
 502          || (INTEGRAL_TYPE_P (TREE_TYPE (@0))
 503              && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0)))
 504          /* For pointer types, if the conversion of A to the
 505             final type requires a sign- or zero-extension,
 506             then we have to punt - it is not defined which
 507             one is correct.  */
 508          || (POINTER_TYPE_P (TREE_TYPE (@0))
 509              && TREE_CODE (@1) == INTEGER_CST
 510              && tree_int_cst_sign_bit (@1) == 0))
 511      (convert @1))))))
 512
 513
 514 /* Simplifications of MIN_EXPR and MAX_EXPR.  */
 515
 516 (for minmax (min max)
 517  (simplify
 518   (minmax @0 @0)
 519   @0))
 520 (simplify
 521  (min @0 @1)
 522  (if (INTEGRAL_TYPE_P (type)
 523       && TYPE_MIN_VALUE (type)
 524       && operand_equal_p (@1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
 525   @1))
 526 (simplify
 527  (max @0 @1)
 528  (if (INTEGRAL_TYPE_P (type)
 529       && TYPE_MAX_VALUE (type)
 530       && operand_equal_p (@1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
 531   @1))
 532
 533
 534 /* Simplifications of shift and rotates.  */
 535
 536 (for rotate (lrotate rrotate)
 537  (simplify
 538   (rotate integer_all_onesp@0 @1)
 539   @0))
 540
 541 /* Optimize -1 >> x for arithmetic right shifts.  */
 542 (simplify
 543  (rshift integer_all_onesp@0 @1)
 544  (if (!TYPE_UNSIGNED (type)
 545       && tree_expr_nonnegative_p (@1))
 546   @0))
 547
 548 (for shiftrotate (lrotate rrotate lshift rshift)
 549  (simplify
 550   (shiftrotate @0 integer_zerop)
 551   (non_lvalue @0))
 552  (simplify
 553   (shiftrotate integer_zerop@0 @1)
 554   @0)
 555  /* Prefer vector1 << scalar to vector1 << vector2
 556     if vector2 is uniform.  */
 557  (for vec (VECTOR_CST CONSTRUCTOR)
 558   (simplify
 559    (shiftrotate @0 vec@1)
 560    (with { tree tem = uniform_vector_p (@1); }
 561     (if (tem)
 562      (shiftrotate @0 { tem; }))))))
 563
 564 /* Rewrite an LROTATE_EXPR by a constant into an
 565    RROTATE_EXPR by a new constant.  */
 566 (simplify
 567  (lrotate @0 INTEGER_CST@1)
 568  (rrotate @0 { fold_binary (MINUS_EXPR, TREE_TYPE (@1),
 569                             build_int_cst (TREE_TYPE (@1),
 570                                            element_precision (type)), @1); }))
 571
 572
 573 /* Simplifications of conversions.  */
 574
 575 /* Basic strip-useless-type-conversions / strip_nops.  */
 576 (for cvt (convert view_convert float fix_trunc)
 577  (simplify
 578   (cvt @0)
 579   (if ((GIMPLE && useless_type_conversion_p (type, TREE_TYPE (@0)))
 580        || (GENERIC && type == TREE_TYPE (@0)))
 581    @0)))
 582
 583 /* Contract view-conversions.  */
 584 (simplify
 585   (view_convert (view_convert @0))
 586   (view_convert @0))
 587
 588 /* For integral conversions with the same precision or pointer
 589    conversions use a NOP_EXPR instead.  */
 590 (simplify
 591   (view_convert @0)
 592   (if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
 593        && (INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0)))
 594        && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (@0)))
 595    (convert @0)))
 596
 597 /* Strip inner integral conversions that do not change precision or size.  */
 598 (simplify
 599   (view_convert (convert@0 @1))
 600   (if ((INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0)))
 601        && (INTEGRAL_TYPE_P (TREE_TYPE (@1)) || POINTER_TYPE_P (TREE_TYPE (@1)))
 602        && (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1)))
 603        && (TYPE_SIZE (TREE_TYPE (@0)) == TYPE_SIZE (TREE_TYPE (@1))))
 604    (view_convert @1)))
 605
 606 /* Re-association barriers around constants and other re-association
 607    barriers can be removed.  */
 608 (simplify
 609  (paren CONSTANT_CLASS_P@0)
 610  @0)
 611 (simplify
 612  (paren (paren@1 @0))
 613  @1)
 614
 615 /* Handle cases of two conversions in a row.  */
 616 (for ocvt (convert float fix_trunc)
 617  (for icvt (convert float)
 618   (simplify
 619    (ocvt (icvt@1 @0))
 620    (with
 621     {
 622       tree inside_type = TREE_TYPE (@0);
 623       tree inter_type = TREE_TYPE (@1);
 624       int inside_int = INTEGRAL_TYPE_P (inside_type);
 625       int inside_ptr = POINTER_TYPE_P (inside_type);
 626       int inside_float = FLOAT_TYPE_P (inside_type);
 627       int inside_vec = VECTOR_TYPE_P (inside_type);
 628       unsigned int inside_prec = TYPE_PRECISION (inside_type);
 629       int inside_unsignedp = TYPE_UNSIGNED (inside_type);
 630       int inter_int = INTEGRAL_TYPE_P (inter_type);
 631       int inter_ptr = POINTER_TYPE_P (inter_type);
 632       int inter_float = FLOAT_TYPE_P (inter_type);
 633       int inter_vec = VECTOR_TYPE_P (inter_type);
 634       unsigned int inter_prec = TYPE_PRECISION (inter_type);
 635       int inter_unsignedp = TYPE_UNSIGNED (inter_type);
 636       int final_int = INTEGRAL_TYPE_P (type);
 637       int final_ptr = POINTER_TYPE_P (type);
 638       int final_float = FLOAT_TYPE_P (type);
 639       int final_vec = VECTOR_TYPE_P (type);
 640       unsigned int final_prec = TYPE_PRECISION (type);
 641       int final_unsignedp = TYPE_UNSIGNED (type);
 642     }
 643    /* In addition to the cases of two conversions in a row
 644       handled below, if we are converting something to its own
 645       type via an object of identical or wider precision, neither
 646       conversion is needed.  */
 647    (if (((GIMPLE && useless_type_conversion_p (type, inside_type))
 648          || (GENERIC
 649              && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
 650         && (((inter_int || inter_ptr) && final_int)
 651             || (inter_float && final_float))
 652         && inter_prec >= final_prec)
 653     (ocvt @0))
 654
 655    /* Likewise, if the intermediate and initial types are either both
 656       float or both integer, we don't need the middle conversion if the
 657       former is wider than the latter and doesn't change the signedness
 658       (for integers).  Avoid this if the final type is a pointer since
 659       then we sometimes need the middle conversion.  Likewise if the
 660       final type has a precision not equal to the size of its mode.  */
 661    (if (((inter_int && inside_int)
 662          || (inter_float && inside_float)
 663          || (inter_vec && inside_vec))
 664         && inter_prec >= inside_prec
 665         && (inter_float || inter_vec
 666             || inter_unsignedp == inside_unsignedp)
 667         && ! (final_prec != GET_MODE_PRECISION (element_mode (type))
 668               && element_mode (type) == element_mode (inter_type))
 669         && ! final_ptr
 670         && (! final_vec || inter_prec == inside_prec))
 671     (ocvt @0))
 672
 673    /* If we have a sign-extension of a zero-extended value, we can
 674       replace that by a single zero-extension.  Likewise if the
 675       final conversion does not change precision we can drop the
 676       intermediate conversion.  */
 677    (if (inside_int && inter_int && final_int
 678         && ((inside_prec < inter_prec && inter_prec < final_prec
 679              && inside_unsignedp && !inter_unsignedp)
 680             || final_prec == inter_prec))
 681     (ocvt @0))
 682
 683    /* Two conversions in a row are not needed unless:
 684         - some conversion is floating-point (overstrict for now), or
 685         - some conversion is a vector (overstrict for now), or
 686         - the intermediate type is narrower than both initial and
 687           final, or
 688         - the intermediate type and innermost type differ in signedness,
 689           and the outermost type is wider than the intermediate, or
 690         - the initial type is a pointer type and the precisions of the
 691           intermediate and final types differ, or
 692         - the final type is a pointer type and the precisions of the
 693           initial and intermediate types differ.  */
 694    (if (! inside_float && ! inter_float && ! final_float
 695         && ! inside_vec && ! inter_vec && ! final_vec
 696         && (inter_prec >= inside_prec || inter_prec >= final_prec)
 697         && ! (inside_int && inter_int
 698               && inter_unsignedp != inside_unsignedp
 699               && inter_prec < final_prec)
 700         && ((inter_unsignedp && inter_prec > inside_prec)
 701             == (final_unsignedp && final_prec > inter_prec))
 702         && ! (inside_ptr && inter_prec != final_prec)
 703         && ! (final_ptr && inside_prec != inter_prec)
 704         && ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
 705               && TYPE_MODE (type) == TYPE_MODE (inter_type)))
 706     (ocvt @0))
 707
 708    /* A truncation to an unsigned type (a zero-extension) should be
 709       canonicalized as bitwise and of a mask.  */
 710    (if (final_int && inter_int && inside_int
 711         && final_prec == inside_prec
 712         && final_prec > inter_prec
 713         && inter_unsignedp)
 714     (convert (bit_and @0 { wide_int_to_tree
 715                              (inside_type,
 716                               wi::mask (inter_prec, false,
 717                                         TYPE_PRECISION (inside_type))); })))
 718
 719    /* If we are converting an integer to a floating-point that can
 720       represent it exactly and back to an integer, we can skip the
 721       floating-point conversion.  */
 722    (if (inside_int && inter_float && final_int &&
 723         (unsigned) significand_size (TYPE_MODE (inter_type))
 724         >= inside_prec - !inside_unsignedp)
 725     (convert @0))))))
 726
 727 /* If we have a narrowing conversion to an integral type that is fed by a
 728    BIT_AND_EXPR, we might be able to remove the BIT_AND_EXPR if it merely
 729    masks off bits outside the final type (and nothing else).  */
 730 (simplify
 731   (convert (bit_and @0 INTEGER_CST@1))
 732   (if (INTEGRAL_TYPE_P (type)
 733        && INTEGRAL_TYPE_P (TREE_TYPE (@0))
 734        && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (@0))
 735        && operand_equal_p (@1, build_low_bits_mask (TREE_TYPE (@1),
 736                                                     TYPE_PRECISION (type)), 0))
 737    (convert @0)))
 738
 739
 740 /* (X /[ex] A) * A -> X.  */
 741 (simplify
 742   (mult (convert? (exact_div @0 @1)) @1)
 743   /* Look through a sign-changing conversion.  */
 744   (if (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (type))
 745    (convert @0)))
 746
 747 /* Canonicalization of binary operations.  */
 748
 749 /* Convert X + -C into X - C.  */
 750 (simplify
 751  (plus @0 REAL_CST@1)
 752  (if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (@1)))
 753   (with { tree tem = fold_unary (NEGATE_EXPR, type, @1); }
 754    (if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
 755     (minus @0 { tem; })))))
 756
 757 /* Convert x+x into x*2.0.  */
 758 (simplify
 759  (plus @0 @0)
 760  (if (SCALAR_FLOAT_TYPE_P (type))
 761   (mult @0 { build_real (type, dconst2); })))
 762
 763 (simplify
 764  (minus integer_zerop @1)
 765  (negate @1))
 766
 767 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
 768    ARG0 is zero and X + ARG0 reduces to X, since that would mean
 769    (-ARG1 + ARG0) reduces to -ARG1.  */
 770 (simplify
 771  (minus real_zerop@0 @1)
 772  (if (fold_real_zero_addition_p (type, @0, 0))
 773   (negate @1)))
 774
 775 /* Transform x * -1 into -x.  */
 776 (simplify
 777  (mult @0 integer_minus_onep)
 778  (negate @0))
 779
 780 /* COMPLEX_EXPR and REALPART/IMAGPART_EXPR cancellations.  */
 781 (simplify
 782  (complex (realpart @0) (imagpart @0))
 783  @0)
 784 (simplify
 785  (realpart (complex @0 @1))
 786  @0)
 787 (simplify
 788  (imagpart (complex @0 @1))
 789  @1)
 790
 791
 792 /* BSWAP simplifications, transforms checked by gcc.dg/builtin-bswap-8.c.  */
 793 (for bswap (BUILT_IN_BSWAP16 BUILT_IN_BSWAP32 BUILT_IN_BSWAP64)
 794  (simplify
 795   (bswap (bswap @0))
 796   @0)
 797  (simplify
 798   (bswap (bit_not (bswap @0)))
 799   (bit_not @0))
 800  (for bitop (bit_xor bit_ior bit_and)
 801   (simplify
 802    (bswap (bitop:c (bswap @0) @1))
 803    (bitop @0 (bswap @1)))))
 804
 805
 806 /* Combine COND_EXPRs and VEC_COND_EXPRs.  */
 807
 808 /* Simplify constant conditions.
 809    Only optimize constant conditions when the selected branch
 810    has the same type as the COND_EXPR.  This avoids optimizing
 811    away "c ? x : throw", where the throw has a void type.
 812    Note that we cannot throw away the fold-const.c variant nor
 813    this one as we depend on doing this transform before possibly
 814    A ? B : B -> B triggers and the fold-const.c one can optimize
 815    0 ? A : B to B even if A has side-effects.  Something
 816    genmatch cannot handle.  */
 817 (simplify
 818  (cond INTEGER_CST@0 @1 @2)
 819  (if (integer_zerop (@0)
 820       && (!VOID_TYPE_P (TREE_TYPE (@2))
 821           || VOID_TYPE_P (type)))
 822   @2)
 823  (if (!integer_zerop (@0)
 824       && (!VOID_TYPE_P (TREE_TYPE (@1))
 825           || VOID_TYPE_P (type)))
 826   @1))
 827 (simplify
 828  (vec_cond VECTOR_CST@0 @1 @2)
 829  (if (integer_all_onesp (@0))
 830   @1)
 831  (if (integer_zerop (@0))
 832   @2))
 833
 834 (for cnd (cond vec_cond)
 835  /* A ? B : (A ? X : C) -> A ? B : C.  */
 836  (simplify
 837   (cnd @0 (cnd @0 @1 @2) @3)
 838   (cnd @0 @1 @3))
 839  (simplify
 840   (cnd @0 @1 (cnd @0 @2 @3))
 841   (cnd @0 @1 @3))
 842
 843  /* A ? B : B -> B.  */
 844  (simplify
 845   (cnd @0 @1 @1)
 846   @1)
 847
 848  /* !A ? B : C -> A ? C : B.  */
 849  (simplify
 850   (cnd (logical_inverted_value truth_valued_p@0) @1 @2)
 851   (cnd @0 @2 @1)))
 852
 853
 854 /* Simplifications of comparisons.  */
 855
 856 /* We can simplify a logical negation of a comparison to the
 857    inverted comparison.  As we cannot compute an expression
 858    operator using invert_tree_comparison we have to simulate
 859    that with expression code iteration.  */
 860 (for cmp (tcc_comparison)
 861      icmp (inverted_tcc_comparison)
 862      ncmp (inverted_tcc_comparison_with_nans)
 863  /* Ideally we'd like to combine the following two patterns
 864     and handle some more cases by using
 865       (logical_inverted_value (cmp @0 @1))
 866     here but for that genmatch would need to "inline" that.
 867     For now implement what forward_propagate_comparison did.  */
 868  (simplify
 869   (bit_not (cmp @0 @1))
 870   (if (VECTOR_TYPE_P (type)
 871        || (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1))
 872    /* Comparison inversion may be impossible for trapping math,
 873       invert_tree_comparison will tell us.  But we can't use
 874       a computed operator in the replacement tree thus we have
 875       to play the trick below.  */
 876    (with { enum tree_code ic = invert_tree_comparison
 877              (cmp, HONOR_NANS (element_mode (@0))); }
 878     (if (ic == icmp)
 879      (icmp @0 @1))
 880     (if (ic == ncmp)
 881      (ncmp @0 @1)))))
 882  (simplify
 883   (bit_xor (cmp @0 @1) integer_truep)
 884   (with { enum tree_code ic = invert_tree_comparison
 885             (cmp, HONOR_NANS (element_mode (@0))); }
 886    (if (ic == icmp)
 887     (icmp @0 @1))
 888    (if (ic == ncmp)
 889     (ncmp @0 @1)))))