]>
Commit | Line | Data |
---|---|---|
3d2cf79f RB |
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) | |
e0ee10ed RB |
31 | |
32 | ||
33 | /* Simplifications of operations with one constant operand and | |
36a60e48 | 34 | simplifications to constants or single values. */ |
e0ee10ed RB |
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 | |
60e09045 | 67 | (op integer_zerop@0 @1) |
e0ee10ed RB |
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 | |
60e09045 | 73 | (op @0 integer_onep) |
e0ee10ed RB |
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 | ||
36a60e48 RB |
91 | /* Canonicalize X ^ ~0 to ~X. */ |
92 | (simplify | |
93 | (bit_xor @0 integer_all_onesp@1) | |
94 | (bit_not @0)) | |
95 | ||
96 | /* x & ~0 -> x */ | |
97 | (simplify | |
98 | (bit_and @0 integer_all_onesp) | |
99 | (non_lvalue @0)) | |
100 | ||
101 | /* x & x -> x, x | x -> x */ | |
102 | (for bitop (bit_and bit_ior) | |
103 | (simplify | |
104 | (bitop @0 @0) | |
105 | (non_lvalue @0))) | |
106 | ||
d4573ffe RB |
107 | |
108 | /* Simplifications of conversions. */ | |
109 | ||
110 | /* Basic strip-useless-type-conversions / strip_nops. */ | |
111 | (for cvt (convert view_convert) | |
112 | (simplify | |
113 | (cvt @0) | |
114 | (if ((GIMPLE && useless_type_conversion_p (type, TREE_TYPE (@0))) | |
115 | || (GENERIC && type == TREE_TYPE (@0))) | |
116 | @0))) | |
117 | ||
118 | /* Contract view-conversions. */ | |
119 | (simplify | |
120 | (view_convert (view_convert @0)) | |
121 | (view_convert @0)) | |
122 | ||
123 | /* For integral conversions with the same precision or pointer | |
124 | conversions use a NOP_EXPR instead. */ | |
125 | (simplify | |
126 | (view_convert @0) | |
127 | (if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type)) | |
128 | && (INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0))) | |
129 | && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (@0))) | |
130 | (convert @0))) | |
131 | ||
132 | /* Strip inner integral conversions that do not change precision or size. */ | |
133 | (simplify | |
134 | (view_convert (convert@0 @1)) | |
135 | (if ((INTEGRAL_TYPE_P (TREE_TYPE (@0)) || POINTER_TYPE_P (TREE_TYPE (@0))) | |
136 | && (INTEGRAL_TYPE_P (TREE_TYPE (@1)) || POINTER_TYPE_P (TREE_TYPE (@1))) | |
137 | && (TYPE_PRECISION (TREE_TYPE (@0)) == TYPE_PRECISION (TREE_TYPE (@1))) | |
138 | && (TYPE_SIZE (TREE_TYPE (@0)) == TYPE_SIZE (TREE_TYPE (@1)))) | |
139 | (view_convert @1))) | |
140 | ||
141 | /* Re-association barriers around constants and other re-association | |
142 | barriers can be removed. */ | |
143 | (simplify | |
144 | (paren CONSTANT_CLASS_P@0) | |
145 | @0) | |
146 | (simplify | |
147 | (paren (paren@1 @0)) | |
148 | @1) |