* xvasprintf.c: New file.
[official-gcc.git] / gcc / match.pd
blob4ccb41a2366e1341d8cd95bd67578e921f50c1fb
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.
5    Copyright (C) 2014 Free Software Foundation, Inc.
6    Contributed by Richard Biener <rguenther@suse.de>
7    and Prathamesh Kulkarni  <bilbotheelffriend@gmail.com>
9 This file is part of GCC.
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.
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.
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/>.  */
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)
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)
43 /* Simplifications of operations with one constant operand and
44    simplifications to constants or single values.  */
46 (for op (plus pointer_plus minus bit_ior bit_xor)
47   (simplify
48     (op @0 integer_zerop)
49     (non_lvalue @0)))
51 /* 0 +p index -> (type)index */
52 (simplify
53  (pointer_plus integer_zerop @1)
54  (non_lvalue (convert @1)))
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)))
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)))
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 (type))
77   { build_zero_cst (type); }))
79 (simplify
80  (mult @0 integer_zerop@1)
81  @1)
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 (type) && !HONOR_SIGNED_ZEROS (element_mode (type)))
90   @1))
92 /* In IEEE floating point, x*1 is not equivalent to x for snans.
93    Likewise for complex arithmetic with signed zeros.  */
94 (simplify
95  (mult @0 real_onep)
96  (if (!HONOR_SNANS (element_mode (type))
97       && (!HONOR_SIGNED_ZEROS (element_mode (type))
98           || !COMPLEX_FLOAT_TYPE_P (type)))
99   (non_lvalue @0)))
101 /* Transform x * -1.0 into -x.  */
102 (simplify
103  (mult @0 real_minus_onep)
104   (if (!HONOR_SNANS (element_mode (type))
105        && (!HONOR_SIGNED_ZEROS (element_mode (type))
106            || !COMPLEX_FLOAT_TYPE_P (type)))
107    (negate @0)))
109 /* Make sure to preserve divisions by zero.  This is the reason why
110    we don't simplify x / x to 1 or 0 / x to 0.  */
111 (for op (mult trunc_div ceil_div floor_div round_div exact_div)
112   (simplify
113     (op @0 integer_onep)
114     (non_lvalue @0)))
116 /* X / -1 is -X.  */
117 (for div (trunc_div ceil_div floor_div round_div exact_div)
118  (simplify
119    (div @0 integer_minus_onep@1)
120    (if (!TYPE_UNSIGNED (type))
121     (negate @0))))
123 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
124    TRUNC_DIV_EXPR.  Rewrite into the latter in this case.  */
125 (simplify
126  (floor_div @0 @1)
127  (if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
128       && TYPE_UNSIGNED (type))
129   (trunc_div @0 @1)))
131 /* Combine two successive divisions.  Note that combining ceil_div
132    and floor_div is trickier and combining round_div even more so.  */
133 (for div (trunc_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         && (TYPE_UNSIGNED (type)
144             || mul != wi::min_value (TYPE_PRECISION (type), SIGNED)))
145     { build_zero_cst (type); }))))
147 /* Optimize A / A to 1.0 if we don't care about
148    NaNs or Infinities.  */
149 (simplify
150  (rdiv @0 @0)
151  (if (FLOAT_TYPE_P (type)
152       && ! HONOR_NANS (type)
153       && ! HONOR_INFINITIES (element_mode (type)))
154   { build_one_cst (type); }))
156 /* Optimize -A / A to -1.0 if we don't care about
157    NaNs or Infinities.  */
158 (simplify
159  (rdiv:c @0 (negate @0))
160  (if (FLOAT_TYPE_P (type)
161       && ! HONOR_NANS (type)
162       && ! HONOR_INFINITIES (element_mode (type)))
163   { build_minus_one_cst (type); }))
165 /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
166 (simplify
167  (rdiv @0 real_onep)
168  (if (!HONOR_SNANS (element_mode (type)))
169   (non_lvalue @0)))
171 /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
172 (simplify
173  (rdiv @0 real_minus_onep)
174  (if (!HONOR_SNANS (element_mode (type)))
175   (negate @0)))
177 /* If ARG1 is a constant, we can convert this to a multiply by the
178    reciprocal.  This does not have the same rounding properties,
179    so only do this if -freciprocal-math.  We can actually
180    always safely do it if ARG1 is a power of two, but it's hard to
181    tell if it is or not in a portable manner.  */
182 (for cst (REAL_CST COMPLEX_CST VECTOR_CST)
183  (simplify
184   (rdiv @0 cst@1)
185   (if (optimize)
186    (if (flag_reciprocal_math
187         && !real_zerop (@1))
188     (with
189      { tree tem = fold_binary (RDIV_EXPR, type, build_one_cst (type), @1); }
190      (if (tem)
191       (mult @0 { tem; } ))))
192    (if (cst != COMPLEX_CST)
193     (with { tree inverse = exact_inverse (type, @1); }
194      (if (inverse)
195       (mult @0 { inverse; } )))))))
197 /* Same applies to modulo operations, but fold is inconsistent here
198    and simplifies 0 % x to 0, only preserving literal 0 % 0.  */
199 (for mod (ceil_mod floor_mod round_mod trunc_mod)
200  /* 0 % X is always zero.  */
201  (simplify
202   (mod integer_zerop@0 @1)
203   /* But not for 0 % 0 so that we can get the proper warnings and errors.  */
204   (if (!integer_zerop (@1))
205    @0))
206  /* X % 1 is always zero.  */
207  (simplify
208   (mod @0 integer_onep)
209   { build_zero_cst (type); })
210  /* X % -1 is zero.  */
211  (simplify
212   (mod @0 integer_minus_onep@1)
213   (if (!TYPE_UNSIGNED (type))
214    { build_zero_cst (type); })))
216 /* X % -C is the same as X % C.  */
217 (simplify
218  (trunc_mod @0 INTEGER_CST@1)
219   (if (TYPE_SIGN (type) == SIGNED
220        && !TREE_OVERFLOW (@1)
221        && wi::neg_p (@1)
222        && !TYPE_OVERFLOW_TRAPS (type)
223        /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
224        && !sign_bit_p (@1, @1))
225    (trunc_mod @0 (negate @1))))
227 /* x | ~0 -> ~0  */
228 (simplify
229   (bit_ior @0 integer_all_onesp@1)
230   @1)
232 /* x & 0 -> 0  */
233 (simplify
234   (bit_and @0 integer_zerop@1)
235   @1)
237 /* x ^ x -> 0 */
238 (simplify
239   (bit_xor @0 @0)
240   { build_zero_cst (type); })
242 /* Canonicalize X ^ ~0 to ~X.  */
243 (simplify
244   (bit_xor @0 integer_all_onesp@1)
245   (bit_not @0))
247 /* x & ~0 -> x  */
248 (simplify
249  (bit_and @0 integer_all_onesp)
250   (non_lvalue @0))
252 /* x & x -> x,  x | x -> x  */
253 (for bitop (bit_and bit_ior)
254  (simplify
255   (bitop @0 @0)
256   (non_lvalue @0)))
258 (simplify
259  (abs (negate @0))
260  (abs @0))
261 (simplify
262  (abs tree_expr_nonnegative_p@0)
263  @0)
266 /* Try to fold (type) X op CST -> (type) (X op ((type-x) CST))
267    when profitable.
268    For bitwise binary operations apply operand conversions to the
269    binary operation result instead of to the operands.  This allows
270    to combine successive conversions and bitwise binary operations.
271    We combine the above two cases by using a conditional convert.  */
272 (for bitop (bit_and bit_ior bit_xor)
273  (simplify
274   (bitop (convert @0) (convert? @1))
275   (if (((TREE_CODE (@1) == INTEGER_CST
276          && INTEGRAL_TYPE_P (TREE_TYPE (@0))
277          && int_fits_type_p (@1, TREE_TYPE (@0)))
278         || (GIMPLE && types_compatible_p (TREE_TYPE (@0), TREE_TYPE (@1)))
279         || (GENERIC && TREE_TYPE (@0) == TREE_TYPE (@1)))
280        /* ???  This transform conflicts with fold-const.c doing
281           Convert (T)(x & c) into (T)x & (T)c, if c is an integer
282           constants (if x has signed type, the sign bit cannot be set
283           in c).  This folds extension into the BIT_AND_EXPR.
284           Restrict it to GIMPLE to avoid endless recursions.  */
285        && (bitop != BIT_AND_EXPR || GIMPLE)
286        && (/* That's a good idea if the conversion widens the operand, thus
287               after hoisting the conversion the operation will be narrower.  */
288            TYPE_PRECISION (TREE_TYPE (@0)) < TYPE_PRECISION (type)
289            /* It's also a good idea if the conversion is to a non-integer
290               mode.  */
291            || GET_MODE_CLASS (TYPE_MODE (type)) != MODE_INT
292            /* Or if the precision of TO is not the same as the precision
293               of its mode.  */
294            || TYPE_PRECISION (type) != GET_MODE_PRECISION (TYPE_MODE (type))))
295    (convert (bitop @0 (convert @1))))))
297 /* Simplify (A & B) OP0 (C & B) to (A OP0 C) & B. */
298 (for bitop (bit_and bit_ior bit_xor)
299  (simplify
300   (bitop (bit_and:c @0 @1) (bit_and @2 @1))
301   (bit_and (bitop @0 @2) @1)))
303 /* (x | CST1) & CST2 -> (x & CST2) | (CST1 & CST2) */
304 (simplify
305   (bit_and (bit_ior @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
306   (bit_ior (bit_and @0 @2) (bit_and @1 @2)))
308 /* Combine successive equal operations with constants.  */
309 (for bitop (bit_and bit_ior bit_xor)
310  (simplify
311   (bitop (bitop @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
312   (bitop @0 (bitop @1 @2))))
314 /* Try simple folding for X op !X, and X op X with the help
315    of the truth_valued_p and logical_inverted_value predicates.  */
316 (match truth_valued_p
317  @0
318  (if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1)))
319 (for op (tcc_comparison truth_and truth_andif truth_or truth_orif truth_xor)
320  (match truth_valued_p
321   (op @0 @1)))
322 (match truth_valued_p
323   (truth_not @0))
325 (match (logical_inverted_value @0)
326  (bit_not truth_valued_p@0))
327 (match (logical_inverted_value @0)
328  (eq @0 integer_zerop))
329 (match (logical_inverted_value @0)
330  (ne truth_valued_p@0 integer_truep))
331 (match (logical_inverted_value @0)
332  (bit_xor truth_valued_p@0 integer_truep))
334 /* X & !X -> 0.  */
335 (simplify
336  (bit_and:c @0 (logical_inverted_value @0))
337  { build_zero_cst (type); })
338 /* X | !X and X ^ !X -> 1, , if X is truth-valued.  */
339 (for op (bit_ior bit_xor)
340  (simplify
341   (op:c truth_valued_p@0 (logical_inverted_value @0))
342   { constant_boolean_node (true, type); }))
344 (for bitop (bit_and bit_ior)
345      rbitop (bit_ior bit_and)
346   /* (x | y) & x -> x */
347   /* (x & y) | x -> x */
348  (simplify
349   (bitop:c (rbitop:c @0 @1) @0)
350   @0)
351  /* (~x | y) & x -> x & y */
352  /* (~x & y) | x -> x | y */
353  (simplify
354   (bitop:c (rbitop:c (bit_not @0) @1) @0)
355   (bitop @0 @1)))
357 /* If arg1 and arg2 are booleans (or any single bit type)
358    then try to simplify:
360    (~X & Y) -> X < Y
361    (X & ~Y) -> Y < X
362    (~X | Y) -> X <= Y
363    (X | ~Y) -> Y <= X
365    But only do this if our result feeds into a comparison as
366    this transformation is not always a win, particularly on
367    targets with and-not instructions.
368    -> simplify_bitwise_binary_boolean */
369 (simplify
370   (ne (bit_and:c (bit_not @0) @1) integer_zerop)
371   (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
372        && TYPE_PRECISION (TREE_TYPE (@1)) == 1)
373    (lt @0 @1)))
374 (simplify
375   (ne (bit_ior:c (bit_not @0) @1) integer_zerop)
376   (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
377        && TYPE_PRECISION (TREE_TYPE (@1)) == 1)
378    (le @0 @1)))
380 /* ~~x -> x */
381 (simplify
382   (bit_not (bit_not @0))
383   @0)
386 /* Associate (p +p off1) +p off2 as (p +p (off1 + off2)).  */
387 (simplify
388   (pointer_plus (pointer_plus@2 @0 @1) @3)
389   (if (TREE_CODE (@2) != SSA_NAME || has_single_use (@2))
390    (pointer_plus @0 (plus @1 @3))))
392 /* Pattern match
393      tem1 = (long) ptr1;
394      tem2 = (long) ptr2;
395      tem3 = tem2 - tem1;
396      tem4 = (unsigned long) tem3;
397      tem5 = ptr1 + tem4;
398    and produce
399      tem5 = ptr2;  */
400 (simplify
401   (pointer_plus @0 (convert?@2 (minus@3 (convert @1) (convert @0))))
402   /* Conditionally look through a sign-changing conversion.  */
403   (if (TYPE_PRECISION (TREE_TYPE (@2)) == TYPE_PRECISION (TREE_TYPE (@3))
404        && ((GIMPLE && useless_type_conversion_p (type, TREE_TYPE (@1)))
405             || (GENERIC && type == TREE_TYPE (@1))))
406    @1))
408 /* Pattern match
409      tem = (sizetype) ptr;
410      tem = tem & algn;
411      tem = -tem;
412      ... = ptr p+ tem;
413    and produce the simpler and easier to analyze with respect to alignment
414      ... = ptr & ~algn;  */
415 (simplify
416   (pointer_plus @0 (negate (bit_and (convert @0) INTEGER_CST@1)))
417   (with { tree algn = wide_int_to_tree (TREE_TYPE (@0), wi::bit_not (@1)); }
418    (bit_and @0 { algn; })))
421 /* We can't reassociate at all for saturating types.  */
422 (if (!TYPE_SATURATING (type))
424  /* Contract negates.  */
425  /* A + (-B) -> A - B */
426  (simplify
427   (plus:c (convert1? @0) (convert2? (negate @1)))
428   /* Apply STRIP_NOPS on @0 and the negate.  */
429   (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
430        && tree_nop_conversion_p (type, TREE_TYPE (@1))
431        && !TYPE_OVERFLOW_SANITIZED (type))
432    (minus (convert @0) (convert @1))))
433  /* A - (-B) -> A + B */
434  (simplify
435   (minus (convert1? @0) (convert2? (negate @1)))
436   (if (tree_nop_conversion_p (type, TREE_TYPE (@0))
437        && tree_nop_conversion_p (type, TREE_TYPE (@1))
438        && !TYPE_OVERFLOW_SANITIZED (type))
439    (plus (convert @0) (convert @1))))
440  /* -(-A) -> A */
441  (simplify
442   (negate (convert? (negate @1)))
443   (if (tree_nop_conversion_p (type, TREE_TYPE (@1))
444        && !TYPE_OVERFLOW_SANITIZED (type))
445    (convert @1)))
447  /* We can't reassociate floating-point or fixed-point plus or minus
448     because of saturation to +-Inf.  */
449  (if (!FLOAT_TYPE_P (type) && !FIXED_POINT_TYPE_P (type))
451   /* Match patterns that allow contracting a plus-minus pair
452      irrespective of overflow issues.  */
453   /* (A +- B) - A       ->  +- B */
454   /* (A +- B) -+ B      ->  A */
455   /* A - (A +- B)       -> -+ B */
456   /* A +- (B -+ A)      ->  +- B */
457   (simplify
458     (minus (plus:c @0 @1) @0)
459     @1)
460   (simplify
461     (minus (minus @0 @1) @0)
462     (negate @1))
463   (simplify
464     (plus:c (minus @0 @1) @1)
465     @0)
466   (simplify
467    (minus @0 (plus:c @0 @1))
468    (negate @1))
469   (simplify
470    (minus @0 (minus @0 @1))
471    @1)
473   /* (A +- CST) +- CST -> A + CST  */
474   (for outer_op (plus minus)
475    (for inner_op (plus minus)
476     (simplify
477      (outer_op (inner_op @0 CONSTANT_CLASS_P@1) CONSTANT_CLASS_P@2)
478      /* If the constant operation overflows we cannot do the transform
479         as we would introduce undefined overflow, for example
480         with (a - 1) + INT_MIN.  */
481      (with { tree cst = fold_binary (outer_op == inner_op
482                                      ? PLUS_EXPR : MINUS_EXPR, type, @1, @2); }
483       (if (cst && !TREE_OVERFLOW (cst))
484        (inner_op @0 { cst; } ))))))
486   /* (CST - A) +- CST -> CST - A  */
487   (for outer_op (plus minus)
488    (simplify
489     (outer_op (minus CONSTANT_CLASS_P@1 @0) CONSTANT_CLASS_P@2)
490     (with { tree cst = fold_binary (outer_op, type, @1, @2); }
491      (if (cst && !TREE_OVERFLOW (cst))
492       (minus { cst; } @0)))))
494   /* ~A + A -> -1 */
495   (simplify
496    (plus:c (bit_not @0) @0)
497    (if (!TYPE_OVERFLOW_TRAPS (type))
498     { build_all_ones_cst (type); }))
500   /* ~A + 1 -> -A */
501   (simplify
502    (plus (convert? (bit_not @0)) integer_each_onep)
503    (if (tree_nop_conversion_p (type, TREE_TYPE (@0)))
504     (negate (convert @0))))
506   /* -A - 1 -> ~A */
507   (simplify
508    (minus (convert? (negate @0)) integer_each_onep)
509    (if (!TYPE_OVERFLOW_TRAPS (type)
510         && tree_nop_conversion_p (type, TREE_TYPE (@0)))
511     (bit_not (convert @0))))
513   /* -1 - A -> ~A */
514   (simplify
515    (minus integer_all_onesp @0)
516    (if (TREE_CODE (type) != COMPLEX_TYPE)
517     (bit_not @0)))
519   /* (T)(P + A) - (T)P -> (T) A */
520   (for add (plus pointer_plus)
521    (simplify
522     (minus (convert (add @0 @1))
523      (convert @0))
524     (if (element_precision (type) <= element_precision (TREE_TYPE (@1))
525          /* For integer types, if A has a smaller type
526             than T the result depends on the possible
527             overflow in P + A.
528             E.g. T=size_t, A=(unsigned)429497295, P>0.
529             However, if an overflow in P + A would cause
530             undefined behavior, we can assume that there
531             is no overflow.  */
532          || (INTEGRAL_TYPE_P (TREE_TYPE (@0))
533              && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0)))
534          /* For pointer types, if the conversion of A to the
535             final type requires a sign- or zero-extension,
536             then we have to punt - it is not defined which
537             one is correct.  */
538          || (POINTER_TYPE_P (TREE_TYPE (@0))
539              && TREE_CODE (@1) == INTEGER_CST
540              && tree_int_cst_sign_bit (@1) == 0))
541      (convert @1))))))
544 /* Simplifications of MIN_EXPR and MAX_EXPR.  */
546 (for minmax (min max)
547  (simplify
548   (minmax @0 @0)
549   @0))
550 (simplify
551  (min @0 @1)
552  (if (INTEGRAL_TYPE_P (type)
553       && TYPE_MIN_VALUE (type)
554       && operand_equal_p (@1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
555   @1))
556 (simplify
557  (max @0 @1)
558  (if (INTEGRAL_TYPE_P (type)
559       && TYPE_MAX_VALUE (type)
560       && operand_equal_p (@1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
561   @1))
564 /* Simplifications of shift and rotates.  */
566 (for rotate (lrotate rrotate)
567  (simplify
568   (rotate integer_all_onesp@0 @1)
569   @0))
571 /* Optimize -1 >> x for arithmetic right shifts.  */
572 (simplify
573  (rshift integer_all_onesp@0 @1)
574  (if (!TYPE_UNSIGNED (type)
575       && tree_expr_nonnegative_p (@1))
576   @0))
578 (for shiftrotate (lrotate rrotate lshift rshift)
579  (simplify
580   (shiftrotate @0 integer_zerop)
581   (non_lvalue @0))
582  (simplify
583   (shiftrotate integer_zerop@0 @1)
584   @0)
585  /* Prefer vector1 << scalar to vector1 << vector2
586     if vector2 is uniform.  */
587  (for vec (VECTOR_CST CONSTRUCTOR)
588   (simplify
589    (shiftrotate @0 vec@1)
590    (with { tree tem = uniform_vector_p (@1); }
591     (if (tem)
592      (shiftrotate @0 { tem; }))))))
594 /* Rewrite an LROTATE_EXPR by a constant into an
595    RROTATE_EXPR by a new constant.  */
596 (simplify
597  (lrotate @0 INTEGER_CST@1)
598  (rrotate @0 { fold_binary (MINUS_EXPR, TREE_TYPE (@1),
599                             build_int_cst (TREE_TYPE (@1),
600                                            element_precision (type)), @1); }))
603 /* Simplifications of conversions.  */
605 /* Basic strip-useless-type-conversions / strip_nops.  */
606 (for cvt (convert view_convert float fix_trunc)
607  (simplify
608   (cvt @0)
609   (if ((GIMPLE && useless_type_conversion_p (type, TREE_TYPE (@0)))
610        || (GENERIC && type == TREE_TYPE (@0)))
611    @0)))
613 /* Contract view-conversions.  */
614 (simplify
615   (view_convert (view_convert @0))
616   (view_convert @0))
618 /* For integral conversions with the same precision or pointer
619    conversions use a NOP_EXPR instead.  */
620 (simplify
621   (view_convert @0)
622   (if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
623        && (INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0)))
624        && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (@0)))
625    (convert @0)))
627 /* Strip inner integral conversions that do not change precision or size.  */
628 (simplify
629   (view_convert (convert@0 @1))
630   (if ((INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0)))
631        && (INTEGRAL_TYPE_P (TREE_TYPE (@1)) || POINTER_TYPE_P (TREE_TYPE (@1)))
632        && (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1)))
633        && (TYPE_SIZE (TREE_TYPE (@0)) == TYPE_SIZE (TREE_TYPE (@1))))
634    (view_convert @1)))
636 /* Re-association barriers around constants and other re-association
637    barriers can be removed.  */
638 (simplify
639  (paren CONSTANT_CLASS_P@0)
640  @0)
641 (simplify
642  (paren (paren@1 @0))
643  @1)
645 /* Handle cases of two conversions in a row.  */
646 (for ocvt (convert float fix_trunc)
647  (for icvt (convert float)
648   (simplify
649    (ocvt (icvt@1 @0))
650    (with
651     {
652       tree inside_type = TREE_TYPE (@0);
653       tree inter_type = TREE_TYPE (@1);
654       int inside_int = INTEGRAL_TYPE_P (inside_type);
655       int inside_ptr = POINTER_TYPE_P (inside_type);
656       int inside_float = FLOAT_TYPE_P (inside_type);
657       int inside_vec = VECTOR_TYPE_P (inside_type);
658       unsigned int inside_prec = TYPE_PRECISION (inside_type);
659       int inside_unsignedp = TYPE_UNSIGNED (inside_type);
660       int inter_int = INTEGRAL_TYPE_P (inter_type);
661       int inter_ptr = POINTER_TYPE_P (inter_type);
662       int inter_float = FLOAT_TYPE_P (inter_type);
663       int inter_vec = VECTOR_TYPE_P (inter_type);
664       unsigned int inter_prec = TYPE_PRECISION (inter_type);
665       int inter_unsignedp = TYPE_UNSIGNED (inter_type);
666       int final_int = INTEGRAL_TYPE_P (type);
667       int final_ptr = POINTER_TYPE_P (type);
668       int final_float = FLOAT_TYPE_P (type);
669       int final_vec = VECTOR_TYPE_P (type);
670       unsigned int final_prec = TYPE_PRECISION (type);
671       int final_unsignedp = TYPE_UNSIGNED (type);
672     }
673    /* In addition to the cases of two conversions in a row
674       handled below, if we are converting something to its own
675       type via an object of identical or wider precision, neither
676       conversion is needed.  */
677    (if (((GIMPLE && useless_type_conversion_p (type, inside_type))
678          || (GENERIC
679              && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (inside_type)))
680         && (((inter_int || inter_ptr) && final_int)
681             || (inter_float && final_float))
682         && inter_prec >= final_prec)
683     (ocvt @0))
685    /* Likewise, if the intermediate and initial types are either both
686       float or both integer, we don't need the middle conversion if the
687       former is wider than the latter and doesn't change the signedness
688       (for integers).  Avoid this if the final type is a pointer since
689       then we sometimes need the middle conversion.  Likewise if the
690       final type has a precision not equal to the size of its mode.  */
691    (if (((inter_int && inside_int)
692          || (inter_float && inside_float)
693          || (inter_vec && inside_vec))
694         && inter_prec >= inside_prec
695         && (inter_float || inter_vec
696             || inter_unsignedp == inside_unsignedp)
697         && ! (final_prec != GET_MODE_PRECISION (element_mode (type))
698               && element_mode (type) == element_mode (inter_type))
699         && ! final_ptr
700         && (! final_vec || inter_prec == inside_prec))
701     (ocvt @0))
703    /* If we have a sign-extension of a zero-extended value, we can
704       replace that by a single zero-extension.  Likewise if the
705       final conversion does not change precision we can drop the
706       intermediate conversion.  */
707    (if (inside_int && inter_int && final_int
708         && ((inside_prec < inter_prec && inter_prec < final_prec
709              && inside_unsignedp && !inter_unsignedp)
710             || final_prec == inter_prec))
711     (ocvt @0))
713    /* Two conversions in a row are not needed unless:
714         - some conversion is floating-point (overstrict for now), or
715         - some conversion is a vector (overstrict for now), or
716         - the intermediate type is narrower than both initial and
717           final, or
718         - the intermediate type and innermost type differ in signedness,
719           and the outermost type is wider than the intermediate, or
720         - the initial type is a pointer type and the precisions of the
721           intermediate and final types differ, or
722         - the final type is a pointer type and the precisions of the
723           initial and intermediate types differ.  */
724    (if (! inside_float && ! inter_float && ! final_float
725         && ! inside_vec && ! inter_vec && ! final_vec
726         && (inter_prec >= inside_prec || inter_prec >= final_prec)
727         && ! (inside_int && inter_int
728               && inter_unsignedp != inside_unsignedp
729               && inter_prec < final_prec)
730         && ((inter_unsignedp && inter_prec > inside_prec)
731             == (final_unsignedp && final_prec > inter_prec))
732         && ! (inside_ptr && inter_prec != final_prec)
733         && ! (final_ptr && inside_prec != inter_prec)
734         && ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
735               && TYPE_MODE (type) == TYPE_MODE (inter_type)))
736     (ocvt @0))
738    /* A truncation to an unsigned type (a zero-extension) should be
739       canonicalized as bitwise and of a mask.  */
740    (if (final_int && inter_int && inside_int
741         && final_prec == inside_prec
742         && final_prec > inter_prec
743         && inter_unsignedp)
744     (convert (bit_and @0 { wide_int_to_tree
745                              (inside_type,
746                               wi::mask (inter_prec, false,
747                                         TYPE_PRECISION (inside_type))); })))
749    /* If we are converting an integer to a floating-point that can
750       represent it exactly and back to an integer, we can skip the
751       floating-point conversion.  */
752    (if (inside_int && inter_float && final_int &&
753         (unsigned) significand_size (TYPE_MODE (inter_type))
754         >= inside_prec - !inside_unsignedp)
755     (convert @0))))))
757 /* If we have a narrowing conversion to an integral type that is fed by a
758    BIT_AND_EXPR, we might be able to remove the BIT_AND_EXPR if it merely
759    masks off bits outside the final type (and nothing else).  */
760 (simplify
761   (convert (bit_and @0 INTEGER_CST@1))
762   (if (INTEGRAL_TYPE_P (type)
763        && INTEGRAL_TYPE_P (TREE_TYPE (@0))
764        && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (@0))
765        && operand_equal_p (@1, build_low_bits_mask (TREE_TYPE (@1),
766                                                     TYPE_PRECISION (type)), 0))
767    (convert @0)))
770 /* (X /[ex] A) * A -> X.  */
771 (simplify
772   (mult (convert? (exact_div @0 @1)) @1)
773   /* Look through a sign-changing conversion.  */
774   (if (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (type))
775    (convert @0)))
777 /* Canonicalization of binary operations.  */
779 /* Convert X + -C into X - C.  */
780 (simplify
781  (plus @0 REAL_CST@1)
782  (if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (@1)))
783   (with { tree tem = fold_unary (NEGATE_EXPR, type, @1); }
784    (if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
785     (minus @0 { tem; })))))
787 /* Convert x+x into x*2.0.  */
788 (simplify
789  (plus @0 @0)
790  (if (SCALAR_FLOAT_TYPE_P (type))
791   (mult @0 { build_real (type, dconst2); })))
793 (simplify
794  (minus integer_zerop @1)
795  (negate @1))
797 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
798    ARG0 is zero and X + ARG0 reduces to X, since that would mean
799    (-ARG1 + ARG0) reduces to -ARG1.  */
800 (simplify
801  (minus real_zerop@0 @1)
802  (if (fold_real_zero_addition_p (type, @0, 0))
803   (negate @1)))
805 /* Transform x * -1 into -x.  */
806 (simplify
807  (mult @0 integer_minus_onep)
808  (negate @0))
810 /* COMPLEX_EXPR and REALPART/IMAGPART_EXPR cancellations.  */
811 (simplify
812  (complex (realpart @0) (imagpart @0))
813  @0)
814 (simplify
815  (realpart (complex @0 @1))
816  @0)
817 (simplify
818  (imagpart (complex @0 @1))
819  @1)
822 /* BSWAP simplifications, transforms checked by gcc.dg/builtin-bswap-8.c.  */
823 (for bswap (BUILT_IN_BSWAP16 BUILT_IN_BSWAP32 BUILT_IN_BSWAP64)
824  (simplify
825   (bswap (bswap @0))
826   @0)
827  (simplify
828   (bswap (bit_not (bswap @0)))
829   (bit_not @0))
830  (for bitop (bit_xor bit_ior bit_and)
831   (simplify
832    (bswap (bitop:c (bswap @0) @1))
833    (bitop @0 (bswap @1)))))
836 /* Combine COND_EXPRs and VEC_COND_EXPRs.  */
838 /* Simplify constant conditions.
839    Only optimize constant conditions when the selected branch
840    has the same type as the COND_EXPR.  This avoids optimizing
841    away "c ? x : throw", where the throw has a void type.
842    Note that we cannot throw away the fold-const.c variant nor
843    this one as we depend on doing this transform before possibly
844    A ? B : B -> B triggers and the fold-const.c one can optimize
845    0 ? A : B to B even if A has side-effects.  Something
846    genmatch cannot handle.  */
847 (simplify
848  (cond INTEGER_CST@0 @1 @2)
849  (if (integer_zerop (@0)
850       && (!VOID_TYPE_P (TREE_TYPE (@2))
851           || VOID_TYPE_P (type)))
852   @2)
853  (if (!integer_zerop (@0)
854       && (!VOID_TYPE_P (TREE_TYPE (@1))
855           || VOID_TYPE_P (type)))
856   @1))
857 (simplify
858  (vec_cond VECTOR_CST@0 @1 @2)
859  (if (integer_all_onesp (@0))
860   @1)
861  (if (integer_zerop (@0))
862   @2))
864 (for cnd (cond vec_cond)
865  /* A ? B : (A ? X : C) -> A ? B : C.  */
866  (simplify
867   (cnd @0 (cnd @0 @1 @2) @3)
868   (cnd @0 @1 @3))
869  (simplify
870   (cnd @0 @1 (cnd @0 @2 @3))
871   (cnd @0 @1 @3))
873  /* A ? B : B -> B.  */
874  (simplify
875   (cnd @0 @1 @1)
876   @1)
878  /* !A ? B : C -> A ? C : B.  */
879  (simplify
880   (cnd (logical_inverted_value truth_valued_p@0) @1 @2)
881   (cnd @0 @2 @1)))
884 /* Simplifications of comparisons.  */
886 /* We can simplify a logical negation of a comparison to the
887    inverted comparison.  As we cannot compute an expression
888    operator using invert_tree_comparison we have to simulate
889    that with expression code iteration.  */
890 (for cmp (tcc_comparison)
891      icmp (inverted_tcc_comparison)
892      ncmp (inverted_tcc_comparison_with_nans)
893  /* Ideally we'd like to combine the following two patterns
894     and handle some more cases by using
895       (logical_inverted_value (cmp @0 @1))
896     here but for that genmatch would need to "inline" that.
897     For now implement what forward_propagate_comparison did.  */
898  (simplify
899   (bit_not (cmp @0 @1))
900   (if (VECTOR_TYPE_P (type)
901        || (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1))
902    /* Comparison inversion may be impossible for trapping math,
903       invert_tree_comparison will tell us.  But we can't use
904       a computed operator in the replacement tree thus we have
905       to play the trick below.  */
906    (with { enum tree_code ic = invert_tree_comparison
907              (cmp, HONOR_NANS (@0)); }
908     (if (ic == icmp)
909      (icmp @0 @1))
910     (if (ic == ncmp)
911      (ncmp @0 @1)))))
912  (simplify
913   (bit_xor (cmp @0 @1) integer_truep)
914   (with { enum tree_code ic = invert_tree_comparison
915             (cmp, HONOR_NANS (@0)); }
916    (if (ic == icmp)
917     (icmp @0 @1))
918    (if (ic == ncmp)
919     (ncmp @0 @1)))))
922 /* Simplification of math builtins.  */
924 (define_operator_list LOG BUILT_IN_LOGF BUILT_IN_LOG BUILT_IN_LOGL)
925 (define_operator_list EXP BUILT_IN_EXPF BUILT_IN_EXP BUILT_IN_EXPL)
926 (define_operator_list LOG2 BUILT_IN_LOG2F BUILT_IN_LOG2 BUILT_IN_LOG2L)
927 (define_operator_list EXP2 BUILT_IN_EXP2F BUILT_IN_EXP2 BUILT_IN_EXP2L)
928 (define_operator_list LOG10 BUILT_IN_LOG10F BUILT_IN_LOG10 BUILT_IN_LOG10L)
929 (define_operator_list EXP10 BUILT_IN_EXP10F BUILT_IN_EXP10 BUILT_IN_EXP10L)
930 (define_operator_list POW BUILT_IN_POWF BUILT_IN_POW BUILT_IN_POWL)
931 (define_operator_list POW10 BUILT_IN_POW10F BUILT_IN_POW10 BUILT_IN_POW10L)
932 (define_operator_list SQRT BUILT_IN_SQRTF BUILT_IN_SQRT BUILT_IN_SQRTL)
933 (define_operator_list CBRT BUILT_IN_CBRTF BUILT_IN_CBRT BUILT_IN_CBRTL)
936 /* fold_builtin_logarithm */
937 (if (flag_unsafe_math_optimizations)
938  /* Special case, optimize logN(expN(x)) = x.  */
939  (for logs (LOG LOG2 LOG10)
940       exps (EXP EXP2 EXP10)
941   (simplify
942    (logs (exps @0))
943     @0))
944  /* Optimize logN(func()) for various exponential functions.  We
945     want to determine the value "x" and the power "exponent" in
946     order to transform logN(x**exponent) into exponent*logN(x).  */
947  (for logs (LOG LOG LOG LOG
948             LOG2 LOG2 LOG2 LOG2
949             LOG10 LOG10 LOG10 LOG10)
950       exps (EXP EXP2 EXP10 POW10)
951   (simplify
952    (logs (exps @0))
953    (with {
954      tree x;
955      switch (exps)
956        {
957        CASE_FLT_FN (BUILT_IN_EXP):
958          /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
959          x = build_real (type, real_value_truncate (TYPE_MODE (type),
960                                                     dconst_e ()));
961          break;
962        CASE_FLT_FN (BUILT_IN_EXP2):
963          /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
964          x = build_real (type, dconst2);
965          break;
966        CASE_FLT_FN (BUILT_IN_EXP10):
967        CASE_FLT_FN (BUILT_IN_POW10):
968          /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
969          {
970            REAL_VALUE_TYPE dconst10;
971            real_from_integer (&dconst10, VOIDmode, 10, SIGNED);
972            x = build_real (type, dconst10);
973          }
974          break;
975        }
976      }
977     (mult (logs { x; }) @0))))
978  (for logs (LOG LOG
979             LOG2 LOG2
980             LOG10 LOG10)
981       exps (SQRT CBRT)
982   (simplify
983    (logs (exps @0))
984    (with {
985      tree x;
986      switch (exps)
987        {
988        CASE_FLT_FN (BUILT_IN_SQRT):
989          /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
990          x = build_real (type, dconsthalf);
991          break;
992        CASE_FLT_FN (BUILT_IN_CBRT):
993          /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
994          x = build_real (type, real_value_truncate (TYPE_MODE (type),
995                                                     dconst_third ()));
996          break;
997        }
998      }
999     (mult { x; } (logs @0)))))
1000  /* logN(pow(x,exponent) -> exponent*logN(x).  */
1001  (for logs (LOG LOG2 LOG10)
1002       pows (POW)
1003   (simplify
1004    (logs (pows @0 @1))
1005    (mult @1 (logs @0)))))