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
  91
  92 /* Simplifications of conversions.  */
  93
  94 /* Basic strip-useless-type-conversions / strip_nops.  */
  95 (for cvt (convert view_convert)
  96  (simplify
  97   (cvt @0)
  98   (if ((GIMPLE && useless_type_conversion_p (type, TREE_TYPE (@0)))
  99        || (GENERIC && type == TREE_TYPE (@0)))
 100    @0)))
 101
 102 /* Contract view-conversions.  */
 103 (simplify
 104   (view_convert (view_convert @0))
 105   (view_convert @0))
 106
 107 /* For integral conversions with the same precision or pointer
 108    conversions use a NOP_EXPR instead.  */
 109 (simplify
 110   (view_convert @0)
 111   (if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
 112        && (INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0)))
 113        && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (@0)))
 114    (convert @0)))
 115
 116 /* Strip inner integral conversions that do not change precision or size.  */
 117 (simplify
 118   (view_convert (convert@0 @1))
 119   (if ((INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0)))
 120        && (INTEGRAL_TYPE_P (TREE_TYPE (@1)) || POINTER_TYPE_P (TREE_TYPE (@1)))
 121        && (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1)))
 122        && (TYPE_SIZE (TREE_TYPE (@0)) == TYPE_SIZE (TREE_TYPE (@1))))
 123    (view_convert @1)))
 124
 125 /* Re-association barriers around constants and other re-association
 126    barriers can be removed.  */
 127 (simplify
 128  (paren CONSTANT_CLASS_P@0)
 129  @0)
 130 (simplify
 131  (paren (paren@1 @0))
 132  @1)