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@2 @0 @1) @3)
 374   (if (TREE_CODE (@2) != SSA_NAME || has_single_use (@2))
 375    (pointer_plus @0 (plus @1 @3))))
 376
 377 /* Pattern match
 378      tem1 = (long) ptr1;
 379      tem2 = (long) ptr2;
 380      tem3 = tem2 - tem1;
 381      tem4 = (unsigned long) tem3;
 382      tem5 = ptr1 + tem4;
 383    and produce
 384      tem5 = ptr2;  */
 385 (simplify
 386   (pointer_plus @0 (convert?@2 (minus@3 (convert @1) (convert @0))))
 387   /* Conditionally look through a sign-changing conversion.  */
 388   (if (TYPE_PRECISION (TREE_TYPE (@2)) == TYPE_PRECISION (TREE_TYPE (@3))
 389        && ((GIMPLE && useless_type_conversion_p (type, TREE_TYPE (@1)))
 390             || (GENERIC && type == TREE_TYPE (@1))))
 391    @1))
 392
 393 /* Pattern match
 394      tem = (sizetype) ptr;
 395      tem = tem & algn;
 396      tem = -tem;
 397      ... = ptr p+ tem;
 398    and produce the simpler and easier to analyze with respect to alignment
 399      ... = ptr & ~algn;  */
 400 (simplify
 401   (pointer_plus @0 (negate (bit_and (convert @0) INTEGER_CST@1)))
 402   (with { tree algn = wide_int_to_tree (TREE_TYPE (@0), wi::bit_not (@1)); }
 403    (bit_and @0 { algn; })))
 404
 405
 406 /* We can't reassociate at all for saturating types.  */
 407 (if (!TYPE_SATURATING (type))
 408
 409  /* Contract negates.  */
 410  /* A + (-B) -> A - B */
 411  (simplify
 412   (plus:c (convert1? @0) (convert2? (negate @1)))
 413   /* Apply STRIP_NOPS on @0 and the negate.  */
 414   (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
 415        && tree_nop_conversion_p (type, TREE_TYPE (@1))
 416        && !TYPE_OVERFLOW_SANITIZED (type))
 417    (minus (convert @0) (convert @1))))
 418  /* A - (-B) -> A + B */
 419  (simplify
 420   (minus (convert1? @0) (convert2? (negate @1)))
 421   (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
 422        && tree_nop_conversion_p (type, TREE_TYPE (@1))
 423        && !TYPE_OVERFLOW_SANITIZED (type))
 424    (plus (convert @0) (convert @1))))
 425  /* -(-A) -> A */
 426  (simplify
 427   (negate (convert? (negate @1)))
 428   (if (tree_nop_conversion_p (type, TREE_TYPE (@1))
 429        && !TYPE_OVERFLOW_SANITIZED (type))
 430    (convert @1)))
 431
 432  /* We can't reassociate floating-point or fixed-point plus or minus
 433     because of saturation to +-Inf.  */
 434  (if (!FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type))
 435
 436   /* Match patterns that allow contracting a plus-minus pair
 437      irrespective of overflow issues.  */
 438   /* (A +- B) - A       ->  +- B */
 439   /* (A +- B) -+ B      ->  A */
 440   /* A - (A +- B)       -> -+ B */
 441   /* A +- (B -+ A)      ->  +- B */
 442   (simplify
 443     (minus (plus:c @0 @1) @0)
 444     @1)
 445   (simplify
 446     (minus (minus @0 @1) @0)
 447     (negate @1))
 448   (simplify
 449     (plus:c (minus @0 @1) @1)
 450     @0)
 451   (simplify
 452    (minus @0 (plus:c @0 @1))
 453    (negate @1))
 454   (simplify
 455    (minus @0 (minus @0 @1))
 456    @1)
 457
 458   /* (A +- CST) +- CST -> A + CST  */
 459   (for outer_op (plus minus)
 460    (for inner_op (plus minus)
 461     (simplify
 462      (outer_op (inner_op @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
 463      /* If the constant operation overflows we cannot do the transform
 464         as we would introduce undefined overflow, for example
 465         with (a - 1) + INT_MIN.  */
 466      (with { tree cst = fold_binary (outer_op == inner_op
 467                                      ? PLUS_EXPR : MINUS_EXPR, type, @1, @2); }
 468       (if (cst && !TREE_OVERFLOW (cst))
 469        (inner_op @0 { cst; } ))))))
 470
 471   /* (CST - A) +- CST -> CST - A  */
 472   (for outer_op (plus minus)
 473    (simplify
 474     (outer_op (minus CONSTANT_CLASS_P@1 @0) CONSTANT_CLASS_P@2)
 475     (with { tree cst = fold_binary (outer_op, type, @1, @2); }
 476      (if (cst && !TREE_OVERFLOW (cst))
 477       (minus { cst; } @0)))))
 478
 479   /* ~A + A -> -1 */
 480   (simplify
 481    (plus:c (bit_not @0) @0)
 482    (if (!TYPE_OVERFLOW_TRAPS (type))
 483     { build_all_ones_cst (type); }))
 484
 485   /* ~A + 1 -> -A */
 486   (simplify
 487    (plus (bit_not @0) integer_each_onep)
 488    (negate @0))
 489
 490   /* (T)(P + A) - (T)P -> (T) A */
 491   (for add (plus pointer_plus)
 492    (simplify
 493     (minus (convert (add @0 @1))
 494      (convert @0))
 495     (if (element_precision (type) <= element_precision (TREE_TYPE (@1))
 496          /* For integer types, if A has a smaller type
 497             than T the result depends on the possible
 498             overflow in P + A.
 499             E.g. T=size_t, A=(unsigned)429497295, P>0.
 500             However, if an overflow in P + A would cause
 501             undefined behavior, we can assume that there
 502             is no overflow.  */
 503          || (INTEGRAL_TYPE_P (TREE_TYPE (@0))
 504              && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0)))
 505          /* For pointer types, if the conversion of A to the
 506             final type requires a sign- or zero-extension,
 507             then we have to punt - it is not defined which
 508             one is correct.  */
 509          || (POINTER_TYPE_P (TREE_TYPE (@0))
 510              && TREE_CODE (@1) == INTEGER_CST
 511              && tree_int_cst_sign_bit (@1) == 0))
 512      (convert @1))))))
 513
 514
 515 /* Simplifications of MIN_EXPR and MAX_EXPR.  */
 516
 517 (for minmax (min max)
 518  (simplify
 519   (minmax @0 @0)
 520   @0))
 521 (simplify
 522  (min @0 @1)
 523  (if (INTEGRAL_TYPE_P (type)
 524       && TYPE_MIN_VALUE (type)
 525       && operand_equal_p (@1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
 526   @1))
 527 (simplify
 528  (max @0 @1)
 529  (if (INTEGRAL_TYPE_P (type)
 530       && TYPE_MAX_VALUE (type)
 531       && operand_equal_p (@1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
 532   @1))
 533
 534
 535 /* Simplifications of shift and rotates.  */
 536
 537 (for rotate (lrotate rrotate)
 538  (simplify
 539   (rotate integer_all_onesp@0 @1)
 540   @0))
 541
 542 /* Optimize -1 >> x for arithmetic right shifts.  */
 543 (simplify
 544  (rshift integer_all_onesp@0 @1)
 545  (if (!TYPE_UNSIGNED (type)
 546       && tree_expr_nonnegative_p (@1))
 547   @0))
 548
 549 (for shiftrotate (lrotate rrotate lshift rshift)
 550  (simplify
 551   (shiftrotate @0 integer_zerop)
 552   (non_lvalue @0))
 553  (simplify
 554   (shiftrotate integer_zerop@0 @1)
 555   @0)
 556  /* Prefer vector1 << scalar to vector1 << vector2
 557     if vector2 is uniform.  */
 558  (for vec (VECTOR_CST CONSTRUCTOR)
 559   (simplify
 560    (shiftrotate @0 vec@1)
 561    (with { tree tem = uniform_vector_p (@1); }
 562     (if (tem)
 563      (shiftrotate @0 { tem; }))))))
 564
 565 /* Rewrite an LROTATE_EXPR by a constant into an
 566    RROTATE_EXPR by a new constant.  */
 567 (simplify
 568  (lrotate @0 INTEGER_CST@1)
 569  (rrotate @0 { fold_binary (MINUS_EXPR, TREE_TYPE (@1),
 570                             build_int_cst (TREE_TYPE (@1),
 571                                            element_precision (type)), @1); }))
 572
 573
 574 /* Simplifications of conversions.  */
 575
 576 /* Basic strip-useless-type-conversions / strip_nops.  */
 577 (for cvt (convert view_convert float fix_trunc)
 578  (simplify
 579   (cvt @0)
 580   (if ((GIMPLE && useless_type_conversion_p (type, TREE_TYPE (@0)))
 581        || (GENERIC && type == TREE_TYPE (@0)))
 582    @0)))
 583
 584 /* Contract view-conversions.  */
 585 (simplify
 586   (view_convert (view_convert @0))
 587   (view_convert @0))
 588
 589 /* For integral conversions with the same precision or pointer
 590    conversions use a NOP_EXPR instead.  */
 591 (simplify
 592   (view_convert @0)
 593   (if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
 594        && (INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0)))
 595        && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (@0)))
 596    (convert @0)))
 597
 598 /* Strip inner integral conversions that do not change precision or size.  */
 599 (simplify
 600   (view_convert (convert@0 @1))
 601   (if ((INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0)))
 602        && (INTEGRAL_TYPE_P (TREE_TYPE (@1)) || POINTER_TYPE_P (TREE_TYPE (@1)))
 603        && (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1)))
 604        && (TYPE_SIZE (TREE_TYPE (@0)) == TYPE_SIZE (TREE_TYPE (@1))))
 605    (view_convert @1)))
 606
 607 /* Re-association barriers around constants and other re-association
 608    barriers can be removed.  */
 609 (simplify
 610  (paren CONSTANT_CLASS_P@0)
 611  @0)
 612 (simplify
 613  (paren (paren@1 @0))
 614  @1)
 615
 616 /* Handle cases of two conversions in a row.  */
 617 (for ocvt (convert float fix_trunc)
 618  (for icvt (convert float)
 619   (simplify
 620    (ocvt (icvt@1 @0))
 621    (with
 622     {
 623       tree inside_type = TREE_TYPE (@0);
 624       tree inter_type = TREE_TYPE (@1);
 625       int inside_int = INTEGRAL_TYPE_P (inside_type);
 626       int inside_ptr = POINTER_TYPE_P (inside_type);
 627       int inside_float = FLOAT_TYPE_P (inside_type);
 628       int inside_vec = VECTOR_TYPE_P (inside_type);
 629       unsigned int inside_prec = TYPE_PRECISION (inside_type);
 630       int inside_unsignedp = TYPE_UNSIGNED (inside_type);
 631       int inter_int = INTEGRAL_TYPE_P (inter_type);
 632       int inter_ptr = POINTER_TYPE_P (inter_type);
 633       int inter_float = FLOAT_TYPE_P (inter_type);
 634       int inter_vec = VECTOR_TYPE_P (inter_type);
 635       unsigned int inter_prec = TYPE_PRECISION (inter_type);
 636       int inter_unsignedp = TYPE_UNSIGNED (inter_type);
 637       int final_int = INTEGRAL_TYPE_P (type);
 638       int final_ptr = POINTER_TYPE_P (type);
 639       int final_float = FLOAT_TYPE_P (type);
 640       int final_vec = VECTOR_TYPE_P (type);
 641       unsigned int final_prec = TYPE_PRECISION (type);
 642       int final_unsignedp = TYPE_UNSIGNED (type);
 643     }
 644    /* In addition to the cases of two conversions in a row
 645       handled below, if we are converting something to its own
 646       type via an object of identical or wider precision, neither
 647       conversion is needed.  */
 648    (if (((GIMPLE && useless_type_conversion_p (type, inside_type))
 649          || (GENERIC
 650              && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
 651         && (((inter_int || inter_ptr) && final_int)
 652             || (inter_float && final_float))
 653         && inter_prec >= final_prec)
 654     (ocvt @0))
 655
 656    /* Likewise, if the intermediate and initial types are either both
 657       float or both integer, we don't need the middle conversion if the
 658       former is wider than the latter and doesn't change the signedness
 659       (for integers).  Avoid this if the final type is a pointer since
 660       then we sometimes need the middle conversion.  Likewise if the
 661       final type has a precision not equal to the size of its mode.  */
 662    (if (((inter_int && inside_int)
 663          || (inter_float && inside_float)
 664          || (inter_vec && inside_vec))
 665         && inter_prec >= inside_prec
 666         && (inter_float || inter_vec
 667             || inter_unsignedp == inside_unsignedp)
 668         && ! (final_prec != GET_MODE_PRECISION (element_mode (type))
 669               && element_mode (type) == element_mode (inter_type))
 670         && ! final_ptr
 671         && (! final_vec || inter_prec == inside_prec))
 672     (ocvt @0))
 673
 674    /* If we have a sign-extension of a zero-extended value, we can
 675       replace that by a single zero-extension.  Likewise if the
 676       final conversion does not change precision we can drop the
 677       intermediate conversion.  */
 678    (if (inside_int && inter_int && final_int
 679         && ((inside_prec < inter_prec && inter_prec < final_prec
 680              && inside_unsignedp && !inter_unsignedp)
 681             || final_prec == inter_prec))
 682     (ocvt @0))
 683
 684    /* Two conversions in a row are not needed unless:
 685         - some conversion is floating-point (overstrict for now), or
 686         - some conversion is a vector (overstrict for now), or
 687         - the intermediate type is narrower than both initial and
 688           final, or
 689         - the intermediate type and innermost type differ in signedness,
 690           and the outermost type is wider than the intermediate, or
 691         - the initial type is a pointer type and the precisions of the
 692           intermediate and final types differ, or
 693         - the final type is a pointer type and the precisions of the
 694           initial and intermediate types differ.  */
 695    (if (! inside_float && ! inter_float && ! final_float
 696         && ! inside_vec && ! inter_vec && ! final_vec
 697         && (inter_prec >= inside_prec || inter_prec >= final_prec)
 698         && ! (inside_int && inter_int
 699               && inter_unsignedp != inside_unsignedp
 700               && inter_prec < final_prec)
 701         && ((inter_unsignedp && inter_prec > inside_prec)
 702             == (final_unsignedp && final_prec > inter_prec))
 703         && ! (inside_ptr && inter_prec != final_prec)
 704         && ! (final_ptr && inside_prec != inter_prec)
 705         && ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
 706               && TYPE_MODE (type) == TYPE_MODE (inter_type)))
 707     (ocvt @0))
 708
 709    /* A truncation to an unsigned type (a zero-extension) should be
 710       canonicalized as bitwise and of a mask.  */
 711    (if (final_int && inter_int && inside_int
 712         && final_prec == inside_prec
 713         && final_prec > inter_prec
 714         && inter_unsignedp)
 715     (convert (bit_and @0 { wide_int_to_tree
 716                              (inside_type,
 717                               wi::mask (inter_prec, false,
 718                                         TYPE_PRECISION (inside_type))); })))
 719
 720    /* If we are converting an integer to a floating-point that can
 721       represent it exactly and back to an integer, we can skip the
 722       floating-point conversion.  */
 723    (if (inside_int && inter_float && final_int &&
 724         (unsigned) significand_size (TYPE_MODE (inter_type))
 725         >= inside_prec - !inside_unsignedp)
 726     (convert @0))))))
 727
 728 /* If we have a narrowing conversion to an integral type that is fed by a
 729    BIT_AND_EXPR, we might be able to remove the BIT_AND_EXPR if it merely
 730    masks off bits outside the final type (and nothing else).  */
 731 (simplify
 732   (convert (bit_and @0 INTEGER_CST@1))
 733   (if (INTEGRAL_TYPE_P (type)
 734        && INTEGRAL_TYPE_P (TREE_TYPE (@0))
 735        && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (@0))
 736        && operand_equal_p (@1, build_low_bits_mask (TREE_TYPE (@1),
 737                                                     TYPE_PRECISION (type)), 0))
 738    (convert @0)))
 739
 740
 741 /* (X /[ex] A) * A -> X.  */
 742 (simplify
 743   (mult (convert? (exact_div @0 @1)) @1)
 744   /* Look through a sign-changing conversion.  */
 745   (if (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (type))
 746    (convert @0)))
 747
 748 /* Canonicalization of binary operations.  */
 749
 750 /* Convert X + -C into X - C.  */
 751 (simplify
 752  (plus @0 REAL_CST@1)
 753  (if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (@1)))
 754   (with { tree tem = fold_unary (NEGATE_EXPR, type, @1); }
 755    (if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
 756     (minus @0 { tem; })))))
 757
 758 /* Convert x+x into x*2.0.  */
 759 (simplify
 760  (plus @0 @0)
 761  (if (SCALAR_FLOAT_TYPE_P (type))
 762   (mult @0 { build_real (type, dconst2); })))
 763
 764 (simplify
 765  (minus integer_zerop @1)
 766  (negate @1))
 767
 768 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
 769    ARG0 is zero and X + ARG0 reduces to X, since that would mean
 770    (-ARG1 + ARG0) reduces to -ARG1.  */
 771 (simplify
 772  (minus real_zerop@0 @1)
 773  (if (fold_real_zero_addition_p (type, @0, 0))
 774   (negate @1)))
 775
 776 /* Transform x * -1 into -x.  */
 777 (simplify
 778  (mult @0 integer_minus_onep)
 779  (negate @0))
 780
 781 /* COMPLEX_EXPR and REALPART/IMAGPART_EXPR cancellations.  */
 782 (simplify
 783  (complex (realpart @0) (imagpart @0))
 784  @0)
 785 (simplify
 786  (realpart (complex @0 @1))
 787  @0)
 788 (simplify
 789  (imagpart (complex @0 @1))
 790  @1)
 791
 792
 793 /* BSWAP simplifications, transforms checked by gcc.dg/builtin-bswap-8.c.  */
 794 (for bswap (BUILT_IN_BSWAP16 BUILT_IN_BSWAP32 BUILT_IN_BSWAP64)
 795  (simplify
 796   (bswap (bswap @0))
 797   @0)
 798  (simplify
 799   (bswap (bit_not (bswap @0)))
 800   (bit_not @0))
 801  (for bitop (bit_xor bit_ior bit_and)
 802   (simplify
 803    (bswap (bitop:c (bswap @0) @1))
 804    (bitop @0 (bswap @1)))))
 805
 806
 807 /* Combine COND_EXPRs and VEC_COND_EXPRs.  */
 808
 809 /* Simplify constant conditions.
 810    Only optimize constant conditions when the selected branch
 811    has the same type as the COND_EXPR.  This avoids optimizing
 812    away "c ? x : throw", where the throw has a void type.
 813    Note that we cannot throw away the fold-const.c variant nor
 814    this one as we depend on doing this transform before possibly
 815    A ? B : B -> B triggers and the fold-const.c one can optimize
 816    0 ? A : B to B even if A has side-effects.  Something
 817    genmatch cannot handle.  */
 818 (simplify
 819  (cond INTEGER_CST@0 @1 @2)
 820  (if (integer_zerop (@0)
 821       && (!VOID_TYPE_P (TREE_TYPE (@2))
 822           || VOID_TYPE_P (type)))
 823   @2)
 824  (if (!integer_zerop (@0)
 825       && (!VOID_TYPE_P (TREE_TYPE (@1))
 826           || VOID_TYPE_P (type)))
 827   @1))
 828 (simplify
 829  (vec_cond VECTOR_CST@0 @1 @2)
 830  (if (integer_all_onesp (@0))
 831   @1)
 832  (if (integer_zerop (@0))
 833   @2))
 834
 835 (for cnd (cond vec_cond)
 836  /* A ? B : (A ? X : C) -> A ? B : C.  */
 837  (simplify
 838   (cnd @0 (cnd @0 @1 @2) @3)
 839   (cnd @0 @1 @3))
 840  (simplify
 841   (cnd @0 @1 (cnd @0 @2 @3))
 842   (cnd @0 @1 @3))
 843
 844  /* A ? B : B -> B.  */
 845  (simplify
 846   (cnd @0 @1 @1)
 847   @1)
 848
 849  /* !A ? B : C -> A ? C : B.  */
 850  (simplify
 851   (cnd (logical_inverted_value truth_valued_p@0) @1 @2)
 852   (cnd @0 @2 @1)))
 853
 854
 855 /* Simplifications of comparisons.  */
 856
 857 /* We can simplify a logical negation of a comparison to the
 858    inverted comparison.  As we cannot compute an expression
 859    operator using invert_tree_comparison we have to simulate
 860    that with expression code iteration.  */
 861 (for cmp (tcc_comparison)
 862      icmp (inverted_tcc_comparison)
 863      ncmp (inverted_tcc_comparison_with_nans)
 864  /* Ideally we'd like to combine the following two patterns
 865     and handle some more cases by using
 866       (logical_inverted_value (cmp @0 @1))
 867     here but for that genmatch would need to "inline" that.
 868     For now implement what forward_propagate_comparison did.  */
 869  (simplify
 870   (bit_not (cmp @0 @1))
 871   (if (VECTOR_TYPE_P (type)
 872        || (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1))
 873    /* Comparison inversion may be impossible for trapping math,
 874       invert_tree_comparison will tell us.  But we can't use
 875       a computed operator in the replacement tree thus we have
 876       to play the trick below.  */
 877    (with { enum tree_code ic = invert_tree_comparison
 878              (cmp, HONOR_NANS (element_mode (@0))); }
 879     (if (ic == icmp)
 880      (icmp @0 @1))
 881     (if (ic == ncmp)
 882      (ncmp @0 @1)))))
 883  (simplify
 884   (bit_xor (cmp @0 @1) integer_truep)
 885   (with { enum tree_code ic = invert_tree_comparison
 886             (cmp, HONOR_NANS (element_mode (@0))); }
 887    (if (ic == icmp)
 888     (icmp @0 @1))
 889    (if (ic == ncmp)
 890     (ncmp @0 @1)))))