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