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
  29    real_zerop real_onep
  30    CONSTANT_CLASS_P)
  31
  32
  33 /* Simplifications of operations with one constant operand and
  34    simplifications to constants.  */
  35
  36 (for op (plus pointer_plus minus bit_ior bit_xor)
  37   (simplify
  38     (op @0 integer_zerop)
  39     (non_lvalue @0)))
  40
  41 /* Simplify x - x.
  42    This is unsafe for certain floats even in non-IEEE formats.
  43    In IEEE, it is unsafe because it does wrong for NaNs.
  44    Also note that operand_equal_p is always false if an operand
  45    is volatile.  */
  46 (simplify
  47   (minus @0 @0)
  48   (if (!FLOAT_TYPE_P (type) || !HONOR_NANS (TYPE_MODE (type)))
  49    { build_zero_cst (type); }))
  50
  51 (simplify
  52   (mult @0 integer_zerop@1)
  53   @1)
  54
  55 /* Make sure to preserve divisions by zero.  This is the reason why
  56    we don't simplify x / x to 1 or 0 / x to 0.  */
  57 (for op (mult trunc_div ceil_div floor_div round_div exact_div)
  58   (simplify
  59     (op @0 integer_onep)
  60     (non_lvalue @0)))
  61
  62 /* Same applies to modulo operations, but fold is inconsistent here
  63    and simplifies 0 % x to 0, only preserving literal 0 % 0.  */
  64 (for op (ceil_mod floor_mod round_mod trunc_mod)
  65  /* 0 % X is always zero.  */
  66  (simplify
  67   (op integer_zerop@0 @1)
  68   /* But not for 0 % 0 so that we can get the proper warnings and errors.  */
  69   (if (!integer_zerop (@1))
  70    @0))
  71  /* X % 1 is always zero.  */
  72  (simplify
  73   (op @0 integer_onep)
  74   { build_zero_cst (type); }))
  75
  76 /* x | ~0 -> ~0  */
  77 (simplify
  78   (bit_ior @0 integer_all_onesp@1)
  79   @1)
  80
  81 /* x & 0 -> 0  */
  82 (simplify
  83   (bit_and @0 integer_zerop@1)
  84   @1)
  85
  86 /* x ^ x -> 0 */
  87 (simplify
  88   (bit_xor @0 @0)
  89   { build_zero_cst (type); })
  90