Bug Summary

File:objdir/gcc/generic-match.cc
Warning:line 744, column 14
Value stored to 'type' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name generic-match.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -Wno-unused -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-vHrDru.plist -x c++ generic-match.cc
1/* Generated automatically by the program `genmatch' from
2 a IL pattern matching and simplification description. */
3
4#include "generic-match-head.cc"
5
6bool
7tree_nop_convert (tree t, tree *res_ops)
8{
9 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
9, __FUNCTION__))->typed.type)
;
10 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 10, __FUNCTION__))
->base.side_effects_flag)
) return false;
11 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
12 {
13 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
14 {
15 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 15, __FUNCTION__)))))
;
16 {
17/* #line 148 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
18 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
19/* #line 148 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
20 if (tree_nop_conversion_p (type, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 20, __FUNCTION__))->typed.type)
)
21)
22 {
23 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 146, __FILE__"generic-match.cc", __LINE__23);
24 {
25 res_ops[0] = captures[0];
26 return true;
27 }
28next_after_fail1:;
29 }
30 }
31 break;
32 }
33 case VIEW_CONVERT_EXPR:
34 {
35 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 35, __FUNCTION__)))))
;
36 {
37/* #line 151 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
38 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
39/* #line 151 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
40 if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE) && VECTOR_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 40, __FUNCTION__))->typed.type
))->base.code) == VECTOR_TYPE)
41 && known_eq (TYPE_VECTOR_SUBPARTS (type),(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS
(((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 42, __FUNCTION__))->typed.type))))
42 TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[0])))(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS
(((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 42, __FUNCTION__))->typed.type))))
43 && tree_nop_conversion_p (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "generic-match.cc"
, 43, __FUNCTION__))->typed.type)
, TREE_TYPE (TREE_TYPE (captures[0]))((contains_struct_check ((((contains_struct_check ((captures[
0]), (TS_TYPED), "generic-match.cc", 43, __FUNCTION__))->typed
.type)), (TS_TYPED), "generic-match.cc", 43, __FUNCTION__))->
typed.type)
)
44)
45 {
46 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 149, __FILE__"generic-match.cc", __LINE__46);
47 {
48 res_ops[0] = captures[0];
49 return true;
50 }
51next_after_fail2:;
52 }
53 }
54 break;
55 }
56 default:;
57 }
58 return false;
59}
60
61bool
62tree_power_of_two_cand (tree t, tree *res_ops)
63{
64 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
64, __FUNCTION__))->typed.type)
;
65 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 65, __FUNCTION__))
->base.side_effects_flag)
) return false;
66 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
67 {
68 case INTEGER_CST:
69 {
70 {
71/* #line 796 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
72 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
73 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 796, __FILE__"generic-match.cc", __LINE__73);
74 {
75 res_ops[0] = captures[0];
76 return true;
77 }
78next_after_fail3:;
79 }
80 break;
81 }
82 case LSHIFT_EXPR:
83 {
84 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 84, __FUNCTION__)))))
;
85 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 85, __FUNCTION__)))))
;
86 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
87 {
88 case INTEGER_CST:
89 {
90 {
91/* #line 798 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
92 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
93 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 798, __FILE__"generic-match.cc", __LINE__93);
94 {
95 res_ops[0] = captures[0];
96 return true;
97 }
98next_after_fail4:;
99 }
100 break;
101 }
102 default:;
103 }
104 break;
105 }
106 default:;
107 }
108 return false;
109}
110
111bool
112tree_negate_expr_p (tree t)
113{
114 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
114, __FUNCTION__))->typed.type)
;
115 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 115, __FUNCTION__)
)->base.side_effects_flag)
) return false;
116 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
117 {
118 case INTEGER_CST:
119 {
120 {
121/* #line 1678 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
122/* #line 1678 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
123 if ((INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
124 && TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 124
, __FUNCTION__))->base.u.bits.unsigned_flag)
)
125 || (!TYPE_OVERFLOW_SANITIZED (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (type)->base.code) == INTEGER_TYPE) &&
!((((enum tree_code) (type)->base.code) == POINTER_TYPE ||
((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((type), "generic-match.cc", 125, __FUNCTION__))->base.u.
bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
126 && may_negate_without_overflow_p (t))
127)
128 {
129 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1677, __FILE__"generic-match.cc", __LINE__129);
130 {
131 return true;
132 }
133next_after_fail5:;
134 }
135 }
136 break;
137 }
138 case FIXED_CST:
139 {
140 {
141/* #line 1683 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
142 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1683, __FILE__"generic-match.cc", __LINE__142);
143 {
144 return true;
145 }
146next_after_fail6:;
147 }
148 break;
149 }
150 case NEGATE_EXPR:
151 {
152 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 152, __FUNCTION__)))))
;
153 {
154/* #line 1686 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
155 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
156/* #line 1686 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
157 if (!TYPE_OVERFLOW_SANITIZED (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (type)->base.code) == INTEGER_TYPE) &&
!((((enum tree_code) (type)->base.code) == POINTER_TYPE ||
((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((type), "generic-match.cc", 157, __FUNCTION__))->base.u.
bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
158)
159 {
160 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1685, __FILE__"generic-match.cc", __LINE__160);
161 {
162 return true;
163 }
164next_after_fail7:;
165 }
166 }
167 break;
168 }
169 case REAL_CST:
170 {
171 {
172/* #line 1689 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
173/* #line 1689 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
174 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (t))real_isneg (&((*(&(tree_check ((t), "generic-match.cc"
, 174, __FUNCTION__, (REAL_CST)))->real_cst.value))))
175)
176 {
177 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1688, __FILE__"generic-match.cc", __LINE__177);
178 {
179 return true;
180 }
181next_after_fail8:;
182 }
183 }
184 break;
185 }
186 case VECTOR_CST:
187 {
188 {
189/* #line 1694 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
190/* #line 1694 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
191 if (FLOAT_TYPE_P (TREE_TYPE (type))((((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.cc", 191, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE) || ((((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.cc", 191, __FUNCTION__))
->typed.type))->base.code) == COMPLEX_TYPE || (((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.cc"
, 191, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE
)) && (((enum tree_code) (((contains_struct_check (((
(contains_struct_check ((type), (TS_TYPED), "generic-match.cc"
, 191, __FUNCTION__))->typed.type)), (TS_TYPED), "generic-match.cc"
, 191, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
|| TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.cc"
, 191, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
192)
193 {
194 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1693, __FILE__"generic-match.cc", __LINE__194);
195 {
196 return true;
197 }
198next_after_fail9:;
199 }
200 }
201 break;
202 }
203 case MINUS_EXPR:
204 {
205 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 205, __FUNCTION__)))))
;
206 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 206, __FUNCTION__)))))
;
207 {
208/* #line 1697 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
209 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
210/* #line 1697 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
211 if ((ANY_INTEGRAL_TYPE_P (type)((((enum tree_code) (type)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (type)->base.code) == INTEGER_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.cc", 211, __FUNCTION__))->typed.type))->
base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.cc", 211, __FUNCTION__))
->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.cc"
, 211, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
&& TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.cc"
, 211, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
)
212 || (FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.cc", 212, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
213 && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
214 && !HONOR_SIGNED_ZEROS (type))
215)
216 {
217 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1696, __FILE__"generic-match.cc", __LINE__217);
218 {
219 return true;
220 }
221next_after_fail10:;
222 }
223 }
224 break;
225 }
226 default:;
227 }
228 return false;
229}
230
231bool
232tree_truth_valued_p (tree t)
233{
234 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
234, __FUNCTION__))->typed.type)
;
235 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 235, __FUNCTION__)
)->base.side_effects_flag)
) return false;
236 {
237/* #line 1885 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
238 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
239/* #line 1885 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
240 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 240
, __FUNCTION__))->type_common.precision)
== 1
241)
242 {
243 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1884, __FILE__"generic-match.cc", __LINE__243);
244 {
245 return true;
246 }
247next_after_fail11:;
248 }
249 }
250 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
251 {
252 case LT_EXPR:
253 {
254 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 254, __FUNCTION__)))))
;
255 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 255, __FUNCTION__)))))
;
256 {
257/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
258 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
259 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__259);
260 {
261 return true;
262 }
263next_after_fail12:;
264 }
265 break;
266 }
267 case LE_EXPR:
268 {
269 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 269, __FUNCTION__)))))
;
270 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 270, __FUNCTION__)))))
;
271 {
272/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
273 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
274 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__274);
275 {
276 return true;
277 }
278next_after_fail13:;
279 }
280 break;
281 }
282 case EQ_EXPR:
283 {
284 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 284, __FUNCTION__)))))
;
285 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 285, __FUNCTION__)))))
;
286 {
287/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
288 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
289 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__289);
290 {
291 return true;
292 }
293next_after_fail14:;
294 }
295 break;
296 }
297 case NE_EXPR:
298 {
299 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 299, __FUNCTION__)))))
;
300 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 300, __FUNCTION__)))))
;
301 {
302/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
303 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
304 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__304);
305 {
306 return true;
307 }
308next_after_fail15:;
309 }
310 break;
311 }
312 case GE_EXPR:
313 {
314 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 314, __FUNCTION__)))))
;
315 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 315, __FUNCTION__)))))
;
316 {
317/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
318 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
319 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__319);
320 {
321 return true;
322 }
323next_after_fail16:;
324 }
325 break;
326 }
327 case GT_EXPR:
328 {
329 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 329, __FUNCTION__)))))
;
330 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 330, __FUNCTION__)))))
;
331 {
332/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
333 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
334 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__334);
335 {
336 return true;
337 }
338next_after_fail17:;
339 }
340 break;
341 }
342 case UNORDERED_EXPR:
343 {
344 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 344, __FUNCTION__)))))
;
345 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 345, __FUNCTION__)))))
;
346 {
347/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
348 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
349 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__349);
350 {
351 return true;
352 }
353next_after_fail18:;
354 }
355 break;
356 }
357 case ORDERED_EXPR:
358 {
359 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 359, __FUNCTION__)))))
;
360 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 360, __FUNCTION__)))))
;
361 {
362/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
363 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
364 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__364);
365 {
366 return true;
367 }
368next_after_fail19:;
369 }
370 break;
371 }
372 case UNLT_EXPR:
373 {
374 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 374, __FUNCTION__)))))
;
375 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 375, __FUNCTION__)))))
;
376 {
377/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
378 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
379 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__379);
380 {
381 return true;
382 }
383next_after_fail20:;
384 }
385 break;
386 }
387 case UNLE_EXPR:
388 {
389 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 389, __FUNCTION__)))))
;
390 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 390, __FUNCTION__)))))
;
391 {
392/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
393 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
394 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__394);
395 {
396 return true;
397 }
398next_after_fail21:;
399 }
400 break;
401 }
402 case UNGT_EXPR:
403 {
404 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 404, __FUNCTION__)))))
;
405 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 405, __FUNCTION__)))))
;
406 {
407/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
408 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
409 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__409);
410 {
411 return true;
412 }
413next_after_fail22:;
414 }
415 break;
416 }
417 case UNGE_EXPR:
418 {
419 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 419, __FUNCTION__)))))
;
420 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 420, __FUNCTION__)))))
;
421 {
422/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
423 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
424 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__424);
425 {
426 return true;
427 }
428next_after_fail23:;
429 }
430 break;
431 }
432 case UNEQ_EXPR:
433 {
434 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 434, __FUNCTION__)))))
;
435 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 435, __FUNCTION__)))))
;
436 {
437/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
438 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
439 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__439);
440 {
441 return true;
442 }
443next_after_fail24:;
444 }
445 break;
446 }
447 case LTGT_EXPR:
448 {
449 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 449, __FUNCTION__)))))
;
450 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 450, __FUNCTION__)))))
;
451 {
452/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
453 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
454 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__454);
455 {
456 return true;
457 }
458next_after_fail25:;
459 }
460 break;
461 }
462 case TRUTH_AND_EXPR:
463 {
464 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 464, __FUNCTION__)))))
;
465 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 465, __FUNCTION__)))))
;
466 {
467/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
468 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
469 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__469);
470 {
471 return true;
472 }
473next_after_fail26:;
474 }
475 break;
476 }
477 case TRUTH_ANDIF_EXPR:
478 {
479 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 479, __FUNCTION__)))))
;
480 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 480, __FUNCTION__)))))
;
481 {
482/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
483 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
484 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__484);
485 {
486 return true;
487 }
488next_after_fail27:;
489 }
490 break;
491 }
492 case TRUTH_OR_EXPR:
493 {
494 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 494, __FUNCTION__)))))
;
495 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 495, __FUNCTION__)))))
;
496 {
497/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
498 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
499 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__499);
500 {
501 return true;
502 }
503next_after_fail28:;
504 }
505 break;
506 }
507 case TRUTH_ORIF_EXPR:
508 {
509 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 509, __FUNCTION__)))))
;
510 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 510, __FUNCTION__)))))
;
511 {
512/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
513 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
514 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__514);
515 {
516 return true;
517 }
518next_after_fail29:;
519 }
520 break;
521 }
522 case TRUTH_XOR_EXPR:
523 {
524 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 524, __FUNCTION__)))))
;
525 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 525, __FUNCTION__)))))
;
526 {
527/* #line 1888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
528 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
529 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.cc", __LINE__529);
530 {
531 return true;
532 }
533next_after_fail30:;
534 }
535 break;
536 }
537 case TRUTH_NOT_EXPR:
538 {
539 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 539, __FUNCTION__)))))
;
540 {
541/* #line 1890 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
542 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
543 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1890, __FILE__"generic-match.cc", __LINE__543);
544 {
545 return true;
546 }
547next_after_fail31:;
548 }
549 break;
550 }
551 default:;
552 }
553 return false;
554}
555
556bool
557tree_logical_inverted_value (tree t, tree *res_ops)
558{
559 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
559, __FUNCTION__))->typed.type)
;
560 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 560, __FUNCTION__)
)->base.side_effects_flag)
) return false;
561 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
562 {
563 case TRUTH_NOT_EXPR:
564 {
565 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 565, __FUNCTION__)))))
;
566 {
567/* #line 1892 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
568 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
569 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1892, __FILE__"generic-match.cc", __LINE__569);
570 {
571 res_ops[0] = captures[0];
572 return true;
573 }
574next_after_fail32:;
575 }
576 break;
577 }
578 case BIT_NOT_EXPR:
579 {
580 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 580, __FUNCTION__)))))
;
581 if (tree_truth_valued_p (_p0))
582 {
583 {
584/* #line 1894 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
585 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
586 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1894, __FILE__"generic-match.cc", __LINE__586);
587 {
588 res_ops[0] = captures[0];
589 return true;
590 }
591next_after_fail33:;
592 }
593 }
594 break;
595 }
596 case EQ_EXPR:
597 {
598 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 598, __FUNCTION__)))))
;
599 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 599, __FUNCTION__)))))
;
600 if (integer_zerop (_p1))
601 {
602 {
603/* #line 1896 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
604 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
605 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1896, __FILE__"generic-match.cc", __LINE__605);
606 {
607 res_ops[0] = captures[0];
608 return true;
609 }
610next_after_fail34:;
611 }
612 }
613 break;
614 }
615 case NE_EXPR:
616 {
617 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 617, __FUNCTION__)))))
;
618 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 618, __FUNCTION__)))))
;
619 if (tree_truth_valued_p (_p0))
620 {
621 if (integer_truep (_p1))
622 {
623 {
624/* #line 1898 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
625 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
626 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1898, __FILE__"generic-match.cc", __LINE__626);
627 {
628 res_ops[0] = captures[0];
629 return true;
630 }
631next_after_fail35:;
632 }
633 }
634 }
635 break;
636 }
637 case BIT_XOR_EXPR:
638 {
639 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 639, __FUNCTION__)))))
;
640 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 640, __FUNCTION__)))))
;
641 if (tree_truth_valued_p (_p0))
642 {
643 if (integer_truep (_p1))
644 {
645 {
646/* #line 1900 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
647 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
648 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1900, __FILE__"generic-match.cc", __LINE__648);
649 {
650 res_ops[0] = captures[0];
651 return true;
652 }
653next_after_fail36:;
654 }
655 }
656 }
657 break;
658 }
659 default:;
660 }
661 return false;
662}
663
664bool
665tree_zero_one_valued_p (tree t)
666{
667 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
667, __FUNCTION__))->typed.type)
;
668 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 668, __FUNCTION__)
)->base.side_effects_flag)
) return false;
669 {
670/* #line 1925 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
671 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
672/* #line 1925 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
673 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
&& tree_nonzero_bits (captures[0]) == 1
674)
675 {
676 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1924, __FILE__"generic-match.cc", __LINE__676);
677 {
678 return true;
679 }
680next_after_fail37:;
681 }
682 }
683 if (tree_truth_valued_p (t))
684 {
685 {
686/* #line 1927 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
687 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
688 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1927, __FILE__"generic-match.cc", __LINE__688);
689 {
690 return true;
691 }
692next_after_fail38:;
693 }
694 }
695 return false;
696}
697
698bool
699tree_with_possible_nonzero_bits (tree t)
700{
701 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
701, __FUNCTION__))->typed.type)
;
702 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 702, __FUNCTION__)
)->base.side_effects_flag)
) return false;
703 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
704 {
705 case INTEGER_CST:
706 {
707 {
708/* #line 2402 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
709 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
710 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2402, __FILE__"generic-match.cc", __LINE__710);
711 {
712 return true;
713 }
714next_after_fail39:;
715 }
716 break;
717 }
718 case SSA_NAME:
719 {
720 {
721/* #line 2405 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
722 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
723/* #line 2405 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
724 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 724, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 724, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 724, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
|| POINTER_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 724, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 724, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
725)
726 {
727 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2404, __FILE__"generic-match.cc", __LINE__727);
728 {
729 return true;
730 }
731next_after_fail40:;
732 }
733 }
734 break;
735 }
736 default:;
737 }
738 return false;
739}
740
741bool
742tree_with_possible_nonzero_bits2 (tree t, tree *res_ops)
743{
744 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
744, __FUNCTION__))->typed.type)
;
Value stored to 'type' during its initialization is never read
745 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 745, __FUNCTION__)
)->base.side_effects_flag)
) return false;
746 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
747 {
748 case BIT_AND_EXPR:
749 {
750 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 750, __FUNCTION__)))))
;
751 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 751, __FUNCTION__)))))
;
752 if (tree_with_possible_nonzero_bits (_p0))
753 {
754 {
755/* #line 2409 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
756 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
757 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2409, __FILE__"generic-match.cc", __LINE__757);
758 {
759 res_ops[0] = captures[0];
760 return true;
761 }
762next_after_fail41:;
763 }
764 }
765 if (tree_with_possible_nonzero_bits (_p1))
766 {
767 {
768/* #line 2409 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
769 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
770 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2409, __FILE__"generic-match.cc", __LINE__770);
771 {
772 res_ops[0] = captures[0];
773 return true;
774 }
775next_after_fail42:;
776 }
777 }
778 break;
779 }
780 default:;
781 }
782if (tree_with_possible_nonzero_bits (t))
783 {
784 {
785/* #line 2407 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
786 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
787 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2407, __FILE__"generic-match.cc", __LINE__787);
788 {
789 res_ops[0] = captures[0];
790 return true;
791 }
792next_after_fail43:;
793 }
794 }
795 return false;
796}
797
798bool
799tree_with_certain_nonzero_bits2 (tree t, tree *res_ops)
800{
801 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
801, __FUNCTION__))->typed.type)
;
802 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 802, __FUNCTION__)
)->base.side_effects_flag)
) return false;
803 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
804 {
805 case INTEGER_CST:
806 {
807 {
808/* #line 2414 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
809 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
810 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2414, __FILE__"generic-match.cc", __LINE__810);
811 {
812 res_ops[0] = captures[0];
813 return true;
814 }
815next_after_fail44:;
816 }
817 break;
818 }
819 case BIT_IOR_EXPR:
820 {
821 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 821, __FUNCTION__)))))
;
822 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 822, __FUNCTION__)))))
;
823 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
824 {
825 case INTEGER_CST:
826 {
827 {
828/* #line 2416 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
829 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
830 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2416, __FILE__"generic-match.cc", __LINE__830);
831 {
832 res_ops[0] = captures[0];
833 return true;
834 }
835next_after_fail45:;
836 }
837 break;
838 }
839 default:;
840 }
841 break;
842 }
843 default:;
844 }
845 return false;
846}
847
848bool
849tree_min_value (tree t)
850{
851 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
851, __FUNCTION__))->typed.type)
;
852 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 852, __FUNCTION__)
)->base.side_effects_flag)
) return false;
853 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
854 {
855 case INTEGER_CST:
856 {
857 {
858/* #line 2585 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
859/* #line 2585 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
860 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
861 && wi::eq_p (wi::to_wide (t), wi::min_value (type))
862)
863 {
864 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2584, __FILE__"generic-match.cc", __LINE__864);
865 {
866 return true;
867 }
868next_after_fail46:;
869 }
870 }
871 break;
872 }
873 default:;
874 }
875 return false;
876}
877
878bool
879tree_max_value (tree t)
880{
881 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
881, __FUNCTION__))->typed.type)
;
882 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 882, __FUNCTION__)
)->base.side_effects_flag)
) return false;
883 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
884 {
885 case INTEGER_CST:
886 {
887 {
888/* #line 2590 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
889/* #line 2590 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
890 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
891 && wi::eq_p (wi::to_wide (t), wi::max_value (type))
892)
893 {
894 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2589, __FILE__"generic-match.cc", __LINE__894);
895 {
896 return true;
897 }
898next_after_fail47:;
899 }
900 }
901 break;
902 }
903 default:;
904 }
905 return false;
906}
907
908bool
909tree_compositional_complex (tree t)
910{
911 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
911, __FUNCTION__))->typed.type)
;
912 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 912, __FUNCTION__)
)->base.side_effects_flag)
) return false;
913 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
914 {
915 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
916 {
917 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 917, __FUNCTION__)))))
;
918 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
919 {
920 case COMPLEX_EXPR:
921 {
922 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 922, __FUNCTION__)))))
;
923 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 923, __FUNCTION__)))))
;
924 {
925/* #line 4271 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
926 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q21 };
927 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4271, __FILE__"generic-match.cc", __LINE__927);
928 {
929 return true;
930 }
931next_after_fail48:;
932 }
933 break;
934 }
935 default:;
936 }
937 break;
938 }
939 case COMPLEX_EXPR:
940 {
941 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 941, __FUNCTION__)))))
;
942 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 942, __FUNCTION__)))))
;
943 {
944/* #line 4271 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
945 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
946 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 4271, __FILE__"generic-match.cc", __LINE__946);
947 {
948 return true;
949 }
950next_after_fail49:;
951 }
952 break;
953 }
954 default:;
955 }
956 return false;
957}
958
959bool
960tree_double_value_p (tree t)
961{
962 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
962, __FUNCTION__))->typed.type)
;
963 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 963, __FUNCTION__)
)->base.side_effects_flag)
) return false;
964 {
965/* #line 6888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
966 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
967/* #line 6888 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
968 if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 968, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.cc", 968, __FUNCTION__))->
type_common.main_variant)
== double_type_nodeglobal_trees[TI_DOUBLE_TYPE]
969)
970 {
971 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 6887, __FILE__"generic-match.cc", __LINE__971);
972 {
973 return true;
974 }
975next_after_fail50:;
976 }
977 }
978 return false;
979}
980
981bool
982tree_float_value_p (tree t)
983{
984 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
984, __FUNCTION__))->typed.type)
;
985 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 985, __FUNCTION__)
)->base.side_effects_flag)
) return false;
986 {
987/* #line 6909 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
988 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
989/* #line 6909 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
990 if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 990, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.cc", 990, __FUNCTION__))->
type_common.main_variant)
== float_type_nodeglobal_trees[TI_FLOAT_TYPE]
991)
992 {
993 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 6908, __FILE__"generic-match.cc", __LINE__993);
994 {
995 return true;
996 }
997next_after_fail51:;
998 }
999 }
1000 return false;
1001}
1002
1003bool
1004tree_vec_same_elem_p (tree t)
1005{
1006 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
1006, __FUNCTION__))->typed.type)
;
1007 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 1007, __FUNCTION__
))->base.side_effects_flag)
) return false;
1008 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1009 {
1010 case VEC_DUPLICATE_EXPR:
1011 {
1012 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 1012, __FUNCTION__)))))
;
1013 {
1014/* #line 8274 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1015 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
1016 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8274, __FILE__"generic-match.cc", __LINE__1016);
1017 {
1018 return true;
1019 }
1020next_after_fail52:;
1021 }
1022 break;
1023 }
1024 case CONSTRUCTOR:
1025 {
1026 {
1027/* #line 8278 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1028 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
1029/* #line 8278 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1030 if (TREE_CODE (captures[0])((enum tree_code) (captures[0])->base.code) == SSA_NAME
1031 && uniform_vector_p (gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])(tree_check ((captures[0]), "generic-match.cc", 1031, __FUNCTION__
, (SSA_NAME)))->ssa_name.def_stmt
))
1032)
1033 {
1034 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8277, __FILE__"generic-match.cc", __LINE__1034);
1035 {
1036 return true;
1037 }
1038next_after_fail53:;
1039 }
1040 }
1041 break;
1042 }
1043 default:;
1044 }
1045 {
1046/* #line 8283 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1047 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
1048/* #line 8283 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1049 if (uniform_vector_p (captures[0])
1050)
1051 {
1052 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8282, __FILE__"generic-match.cc", __LINE__1052);
1053 {
1054 return true;
1055 }
1056next_after_fail54:;
1057 }
1058 }
1059 return false;
1060}
1061
1062bool
1063tree_ctz_table_index (tree t, tree *res_ops)
1064{
1065 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
1065, __FUNCTION__))->typed.type)
;
1066 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 1066, __FUNCTION__
))->base.side_effects_flag)
) return false;
1067 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1068 {
1069 case RSHIFT_EXPR:
1070 {
1071 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 1071, __FUNCTION__)))))
;
1072 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 1072, __FUNCTION__)))))
;
1073 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1074 {
1075 case MULT_EXPR:
1076 {
1077 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1077, __FUNCTION__)))))
;
1078 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 1078, __FUNCTION__)))))
;
1079 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1080 {
1081 case BIT_AND_EXPR:
1082 {
1083 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 1083, __FUNCTION__)))))
;
1084 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 1084, __FUNCTION__)))))
;
1085 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1086 {
1087 case NEGATE_EXPR:
1088 {
1089 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1089, __FUNCTION__)))))
;
1090 if ((_q31 == _q40 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "generic-match.cc", 1090, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _q40, 0) && types_match (_q31, _q40)))
1091 {
1092 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1093 {
1094 case INTEGER_CST:
1095 {
1096 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1097 {
1098 case INTEGER_CST:
1099 {
1100 {
1101/* #line 8353 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1102 tree captures[3] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q40, _q21, _p1 };
1103 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8353, __FILE__"generic-match.cc", __LINE__1103);
1104 {
1105 res_ops[0] = captures[0];
1106 res_ops[1] = captures[1];
1107 res_ops[2] = captures[2];
1108 return true;
1109 }
1110next_after_fail55:;
1111 }
1112 break;
1113 }
1114 default:;
1115 }
1116 break;
1117 }
1118 default:;
1119 }
1120 }
1121 break;
1122 }
1123 default:;
1124 }
1125 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
1126 {
1127 case NEGATE_EXPR:
1128 {
1129 tree _q50 = TREE_OPERAND (_q31, 0)(*((const_cast<tree*> (tree_operand_check ((_q31), (0),
"generic-match.cc", 1129, __FUNCTION__)))))
;
1130 if ((_q50 == _q30 && ! TREE_SIDE_EFFECTS (_q50)((non_type_check ((_q50), "generic-match.cc", 1130, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q50, _q30, 0) && types_match (_q50, _q30)))
1131 {
1132 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1133 {
1134 case INTEGER_CST:
1135 {
1136 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1137 {
1138 case INTEGER_CST:
1139 {
1140 {
1141/* #line 8353 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1142 tree captures[3] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q21, _p1 };
1143 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8353, __FILE__"generic-match.cc", __LINE__1143);
1144 {
1145 res_ops[0] = captures[0];
1146 res_ops[1] = captures[1];
1147 res_ops[2] = captures[2];
1148 return true;
1149 }
1150next_after_fail56:;
1151 }
1152 break;
1153 }
1154 default:;
1155 }
1156 break;
1157 }
1158 default:;
1159 }
1160 }
1161 break;
1162 }
1163 default:;
1164 }
1165 break;
1166 }
1167 default:;
1168 }
1169 break;
1170 }
1171 default:;
1172 }
1173 break;
1174 }
1175 default:;
1176 }
1177 return false;
1178}
1179
1180bool
1181tree_cond_expr_convert_p (tree t, tree *res_ops)
1182{
1183 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
1183, __FUNCTION__))->typed.type)
;
1184 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 1184, __FUNCTION__
))->base.side_effects_flag)
) return false;
1185 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1186 {
1187 case COND_EXPR:
1188 {
1189 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 1189, __FUNCTION__)))))
;
1190 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 1190, __FUNCTION__)))))
;
1191 tree _p2 = TREE_OPERAND (t, 2)(*((const_cast<tree*> (tree_operand_check ((t), (2), "generic-match.cc"
, 1191, __FUNCTION__)))))
;
1192 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1193 {
1194 case LT_EXPR:
1195 {
1196 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1196, __FUNCTION__)))))
;
1197 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 1197, __FUNCTION__)))))
;
1198 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1199 {
1200 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1201 {
1202 tree _q50 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 1202, __FUNCTION__)))))
;
1203 switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1204 {
1205 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1206 {
1207 tree _q70 = TREE_OPERAND (_p2, 0)(*((const_cast<tree*> (tree_operand_check ((_p2), (0), "generic-match.cc"
, 1207, __FUNCTION__)))))
;
1208 {
1209/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1210 tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1211/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1212 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
1213 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1213, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 1213, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 1213, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1214 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1214, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 1214, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 1214, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1215 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1215, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 1215, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 1215, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1216 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1216
, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1216, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1216, __FUNCTION__))
->type_common.precision)
1217 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1217, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1217, __FUNCTION__))
->type_common.precision)
1218 == TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1218, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1218, __FUNCTION__))
->type_common.precision)
1219 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1219, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1219, __FUNCTION__))
->type_common.precision)
1220 == TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1220, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1220, __FUNCTION__))
->type_common.precision)
1221 && (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1221, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1221, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1221
, __FUNCTION__))->type_common.precision)
1222 || (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1222, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1222, __FUNCTION__))
->base.u.bits.unsigned_flag)
1223 == TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1223, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1223, __FUNCTION__))
->base.u.bits.unsigned_flag)
))
1224 && single_use (captures[5])
1225 && single_use (captures[6])
1226)
1227 {
1228 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1228);
1229 {
1230 res_ops[0] = captures[0];
1231 res_ops[1] = captures[1];
1232 res_ops[2] = captures[2];
1233 res_ops[3] = captures[3];
1234 return true;
1235 }
1236next_after_fail57:;
1237 }
1238 }
1239 break;
1240 }
1241 default:;
1242 }
1243 break;
1244 }
1245 default:;
1246 }
1247 break;
1248 }
1249 case LE_EXPR:
1250 {
1251 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1251, __FUNCTION__)))))
;
1252 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 1252, __FUNCTION__)))))
;
1253 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1254 {
1255 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1256 {
1257 tree _q50 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 1257, __FUNCTION__)))))
;
1258 switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1259 {
1260 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1261 {
1262 tree _q70 = TREE_OPERAND (_p2, 0)(*((const_cast<tree*> (tree_operand_check ((_p2), (0), "generic-match.cc"
, 1262, __FUNCTION__)))))
;
1263 {
1264/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1265 tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1266/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1267 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
1268 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1268, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 1268, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 1268, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1269 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1269, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 1269, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 1269, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1270 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1270, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 1270, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 1270, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1271 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1271
, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1271, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1271, __FUNCTION__))
->type_common.precision)
1272 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1272, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1272, __FUNCTION__))
->type_common.precision)
1273 == TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1273, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1273, __FUNCTION__))
->type_common.precision)
1274 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1274, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1274, __FUNCTION__))
->type_common.precision)
1275 == TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1275, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1275, __FUNCTION__))
->type_common.precision)
1276 && (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1276, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1276, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1276
, __FUNCTION__))->type_common.precision)
1277 || (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1277, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1277, __FUNCTION__))
->base.u.bits.unsigned_flag)
1278 == TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1278, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1278, __FUNCTION__))
->base.u.bits.unsigned_flag)
))
1279 && single_use (captures[5])
1280 && single_use (captures[6])
1281)
1282 {
1283 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1283);
1284 {
1285 res_ops[0] = captures[0];
1286 res_ops[1] = captures[1];
1287 res_ops[2] = captures[2];
1288 res_ops[3] = captures[3];
1289 return true;
1290 }
1291next_after_fail58:;
1292 }
1293 }
1294 break;
1295 }
1296 default:;
1297 }
1298 break;
1299 }
1300 default:;
1301 }
1302 break;
1303 }
1304 case EQ_EXPR:
1305 {
1306 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1306, __FUNCTION__)))))
;
1307 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 1307, __FUNCTION__)))))
;
1308 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1309 {
1310 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1311 {
1312 tree _q50 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 1312, __FUNCTION__)))))
;
1313 switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1314 {
1315 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1316 {
1317 tree _q70 = TREE_OPERAND (_p2, 0)(*((const_cast<tree*> (tree_operand_check ((_p2), (0), "generic-match.cc"
, 1317, __FUNCTION__)))))
;
1318 {
1319/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1320 tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1321/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1322 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
1323 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1323, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 1323, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 1323, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1324 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1324, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 1324, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 1324, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1325 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1325, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 1325, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 1325, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1326 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1326
, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1326, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1326, __FUNCTION__))
->type_common.precision)
1327 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1327, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1327, __FUNCTION__))
->type_common.precision)
1328 == TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1328, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1328, __FUNCTION__))
->type_common.precision)
1329 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1329, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1329, __FUNCTION__))
->type_common.precision)
1330 == TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1330, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1330, __FUNCTION__))
->type_common.precision)
1331 && (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1331, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1331, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1331
, __FUNCTION__))->type_common.precision)
1332 || (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1332, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1332, __FUNCTION__))
->base.u.bits.unsigned_flag)
1333 == TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1333, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1333, __FUNCTION__))
->base.u.bits.unsigned_flag)
))
1334 && single_use (captures[5])
1335 && single_use (captures[6])
1336)
1337 {
1338 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1338);
1339 {
1340 res_ops[0] = captures[0];
1341 res_ops[1] = captures[1];
1342 res_ops[2] = captures[2];
1343 res_ops[3] = captures[3];
1344 return true;
1345 }
1346next_after_fail59:;
1347 }
1348 }
1349 break;
1350 }
1351 default:;
1352 }
1353 break;
1354 }
1355 default:;
1356 }
1357 break;
1358 }
1359 case NE_EXPR:
1360 {
1361 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1361, __FUNCTION__)))))
;
1362 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 1362, __FUNCTION__)))))
;
1363 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1364 {
1365 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1366 {
1367 tree _q50 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 1367, __FUNCTION__)))))
;
1368 switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1369 {
1370 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1371 {
1372 tree _q70 = TREE_OPERAND (_p2, 0)(*((const_cast<tree*> (tree_operand_check ((_p2), (0), "generic-match.cc"
, 1372, __FUNCTION__)))))
;
1373 {
1374/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1375 tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1376/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1377 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
1378 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1378, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 1378, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 1378, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1379 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1379, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 1379, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 1379, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1380 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1380, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 1380, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 1380, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1381 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1381
, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1381, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1381, __FUNCTION__))
->type_common.precision)
1382 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1382, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1382, __FUNCTION__))
->type_common.precision)
1383 == TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1383, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1383, __FUNCTION__))
->type_common.precision)
1384 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1384, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1384, __FUNCTION__))
->type_common.precision)
1385 == TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1385, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1385, __FUNCTION__))
->type_common.precision)
1386 && (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1386, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1386, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1386
, __FUNCTION__))->type_common.precision)
1387 || (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1387, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1387, __FUNCTION__))
->base.u.bits.unsigned_flag)
1388 == TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1388, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1388, __FUNCTION__))
->base.u.bits.unsigned_flag)
))
1389 && single_use (captures[5])
1390 && single_use (captures[6])
1391)
1392 {
1393 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1393);
1394 {
1395 res_ops[0] = captures[0];
1396 res_ops[1] = captures[1];
1397 res_ops[2] = captures[2];
1398 res_ops[3] = captures[3];
1399 return true;
1400 }
1401next_after_fail60:;
1402 }
1403 }
1404 break;
1405 }
1406 default:;
1407 }
1408 break;
1409 }
1410 default:;
1411 }
1412 break;
1413 }
1414 case GE_EXPR:
1415 {
1416 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1416, __FUNCTION__)))))
;
1417 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 1417, __FUNCTION__)))))
;
1418 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1419 {
1420 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1421 {
1422 tree _q50 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 1422, __FUNCTION__)))))
;
1423 switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1424 {
1425 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1426 {
1427 tree _q70 = TREE_OPERAND (_p2, 0)(*((const_cast<tree*> (tree_operand_check ((_p2), (0), "generic-match.cc"
, 1427, __FUNCTION__)))))
;
1428 {
1429/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1430 tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1431/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1432 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
1433 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1433, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 1433, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 1433, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1434 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1434, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 1434, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 1434, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1435 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1435, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 1435, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 1435, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1436 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1436
, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1436, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1436, __FUNCTION__))
->type_common.precision)
1437 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1437, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1437, __FUNCTION__))
->type_common.precision)
1438 == TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1438, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1438, __FUNCTION__))
->type_common.precision)
1439 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1439, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1439, __FUNCTION__))
->type_common.precision)
1440 == TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1440, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1440, __FUNCTION__))
->type_common.precision)
1441 && (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1441, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1441, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1441
, __FUNCTION__))->type_common.precision)
1442 || (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1442, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1442, __FUNCTION__))
->base.u.bits.unsigned_flag)
1443 == TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1443, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1443, __FUNCTION__))
->base.u.bits.unsigned_flag)
))
1444 && single_use (captures[5])
1445 && single_use (captures[6])
1446)
1447 {
1448 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1448);
1449 {
1450 res_ops[0] = captures[0];
1451 res_ops[1] = captures[1];
1452 res_ops[2] = captures[2];
1453 res_ops[3] = captures[3];
1454 return true;
1455 }
1456next_after_fail61:;
1457 }
1458 }
1459 break;
1460 }
1461 default:;
1462 }
1463 break;
1464 }
1465 default:;
1466 }
1467 break;
1468 }
1469 case GT_EXPR:
1470 {
1471 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1471, __FUNCTION__)))))
;
1472 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 1472, __FUNCTION__)))))
;
1473 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1474 {
1475 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1476 {
1477 tree _q50 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 1477, __FUNCTION__)))))
;
1478 switch (TREE_CODE (_p2)((enum tree_code) (_p2)->base.code))
1479 {
1480 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1481 {
1482 tree _q70 = TREE_OPERAND (_p2, 0)(*((const_cast<tree*> (tree_operand_check ((_p2), (0), "generic-match.cc"
, 1482, __FUNCTION__)))))
;
1483 {
1484/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1485 tree captures[7] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q50, _q70, _p0, _q21, _p1, _p2 };
1486/* #line 8358 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1487 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
1488 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1488, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 1488, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 1488, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1489 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1489, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 1489, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 1489, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1490 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1490, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 1490, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 1490, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1491 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1491
, __FUNCTION__))->type_common.precision)
!= TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1491, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1491, __FUNCTION__))
->type_common.precision)
1492 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1492, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1492, __FUNCTION__))
->type_common.precision)
1493 == TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1493, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1493, __FUNCTION__))
->type_common.precision)
1494 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1494, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1494, __FUNCTION__))
->type_common.precision)
1495 == TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1495, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1495, __FUNCTION__))
->type_common.precision)
1496 && (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 1496, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1496, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 1496
, __FUNCTION__))->type_common.precision)
1497 || (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 1497, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1497, __FUNCTION__))
->base.u.bits.unsigned_flag)
1498 == TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 1498, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 1498, __FUNCTION__))
->base.u.bits.unsigned_flag)
))
1499 && single_use (captures[5])
1500 && single_use (captures[6])
1501)
1502 {
1503 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8356, __FILE__"generic-match.cc", __LINE__1503);
1504 {
1505 res_ops[0] = captures[0];
1506 res_ops[1] = captures[1];
1507 res_ops[2] = captures[2];
1508 res_ops[3] = captures[3];
1509 return true;
1510 }
1511next_after_fail62:;
1512 }
1513 }
1514 break;
1515 }
1516 default:;
1517 }
1518 break;
1519 }
1520 default:;
1521 }
1522 break;
1523 }
1524 default:;
1525 }
1526 break;
1527 }
1528 default:;
1529 }
1530 return false;
1531}
1532
1533bool
1534tree_bitwise_induction_p (tree t, tree *res_ops)
1535{
1536 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.cc",
1536, __FUNCTION__))->typed.type)
;
1537 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.cc", 1537, __FUNCTION__
))->base.side_effects_flag)
) return false;
1538 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1539 {
1540 case BIT_AND_EXPR:
1541 {
1542 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 1542, __FUNCTION__)))))
;
1543 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 1543, __FUNCTION__)))))
;
1544 {
1545 tree _p0_pops[1];
1546 if (tree_nop_convert (_p0, _p0_pops))
1547 {
1548 tree _q20 = _p0_pops[0];
1549 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1550 {
1551 case BIT_NOT_EXPR:
1552 {
1553 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 1553, __FUNCTION__)))))
;
1554 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1555 {
1556 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1557 {
1558 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1558, __FUNCTION__)))))
;
1559 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
1560 {
1561 case LSHIFT_EXPR:
1562 {
1563 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 1563, __FUNCTION__)))))
;
1564 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 1564, __FUNCTION__)))))
;
1565 if (integer_onep (_q50))
1566 {
1567 {
1568/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1569 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q51, _p1, _q50 };
1570 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1570);
1571 {
1572 res_ops[0] = captures[0];
1573 res_ops[1] = captures[1];
1574 res_ops[2] = captures[2];
1575 return true;
1576 }
1577next_after_fail63:;
1578 }
1579 }
1580 break;
1581 }
1582 default:;
1583 }
1584 break;
1585 }
1586 case LSHIFT_EXPR:
1587 {
1588 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1588, __FUNCTION__)))))
;
1589 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 1589, __FUNCTION__)))))
;
1590 if (integer_onep (_q40))
1591 {
1592 {
1593/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1594 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
1595 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1595);
1596 {
1597 res_ops[0] = captures[0];
1598 res_ops[1] = captures[1];
1599 res_ops[2] = captures[2];
1600 return true;
1601 }
1602next_after_fail64:;
1603 }
1604 }
1605 break;
1606 }
1607 default:;
1608 }
1609 break;
1610 }
1611 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1612 {
1613 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 1613, __FUNCTION__)))))
;
1614 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1615 {
1616 case LSHIFT_EXPR:
1617 {
1618 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1618, __FUNCTION__)))))
;
1619 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 1619, __FUNCTION__)))))
;
1620 if (integer_onep (_q40))
1621 {
1622 {
1623/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1624 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
1625 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1625);
1626 {
1627 res_ops[0] = captures[0];
1628 res_ops[1] = captures[1];
1629 res_ops[2] = captures[2];
1630 return true;
1631 }
1632next_after_fail65:;
1633 }
1634 }
1635 break;
1636 }
1637 default:;
1638 }
1639 break;
1640 }
1641 case LSHIFT_EXPR:
1642 {
1643 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 1643, __FUNCTION__)))))
;
1644 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 1644, __FUNCTION__)))))
;
1645 if (integer_onep (_q30))
1646 {
1647 {
1648/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1649 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q31, _p1, _q30 };
1650 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1650);
1651 {
1652 res_ops[0] = captures[0];
1653 res_ops[1] = captures[1];
1654 res_ops[2] = captures[2];
1655 return true;
1656 }
1657next_after_fail66:;
1658 }
1659 }
1660 break;
1661 }
1662 default:;
1663 }
1664}
1665 }
1666 {
1667 tree _p1_pops[1];
1668 if (tree_nop_convert (_p1, _p1_pops))
1669 {
1670 tree _q30 = _p1_pops[0];
1671 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1672 {
1673 case BIT_NOT_EXPR:
1674 {
1675 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1675, __FUNCTION__)))))
;
1676 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
1677 {
1678 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1679 {
1680 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 1680, __FUNCTION__)))))
;
1681 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
1682 {
1683 case LSHIFT_EXPR:
1684 {
1685 tree _q60 = TREE_OPERAND (_q50, 0)(*((const_cast<tree*> (tree_operand_check ((_q50), (0),
"generic-match.cc", 1685, __FUNCTION__)))))
;
1686 tree _q61 = TREE_OPERAND (_q50, 1)(*((const_cast<tree*> (tree_operand_check ((_q50), (1),
"generic-match.cc", 1686, __FUNCTION__)))))
;
1687 if (integer_onep (_q60))
1688 {
1689 {
1690/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1691 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q61, _p0, _q60 };
1692 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1692);
1693 {
1694 res_ops[0] = captures[0];
1695 res_ops[1] = captures[1];
1696 res_ops[2] = captures[2];
1697 return true;
1698 }
1699next_after_fail67:;
1700 }
1701 }
1702 break;
1703 }
1704 default:;
1705 }
1706 break;
1707 }
1708 case LSHIFT_EXPR:
1709 {
1710 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 1710, __FUNCTION__)))))
;
1711 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 1711, __FUNCTION__)))))
;
1712 if (integer_onep (_q50))
1713 {
1714 {
1715/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1716 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
1717 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1717);
1718 {
1719 res_ops[0] = captures[0];
1720 res_ops[1] = captures[1];
1721 res_ops[2] = captures[2];
1722 return true;
1723 }
1724next_after_fail68:;
1725 }
1726 }
1727 break;
1728 }
1729 default:;
1730 }
1731 break;
1732 }
1733 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1734 {
1735 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1735, __FUNCTION__)))))
;
1736 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
1737 {
1738 case LSHIFT_EXPR:
1739 {
1740 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 1740, __FUNCTION__)))))
;
1741 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 1741, __FUNCTION__)))))
;
1742 if (integer_onep (_q50))
1743 {
1744 {
1745/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1746 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
1747 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1747);
1748 {
1749 res_ops[0] = captures[0];
1750 res_ops[1] = captures[1];
1751 res_ops[2] = captures[2];
1752 return true;
1753 }
1754next_after_fail69:;
1755 }
1756 }
1757 break;
1758 }
1759 default:;
1760 }
1761 break;
1762 }
1763 case LSHIFT_EXPR:
1764 {
1765 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1765, __FUNCTION__)))))
;
1766 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 1766, __FUNCTION__)))))
;
1767 if (integer_onep (_q40))
1768 {
1769 {
1770/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1771 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q41, _p0, _q40 };
1772 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1772);
1773 {
1774 res_ops[0] = captures[0];
1775 res_ops[1] = captures[1];
1776 res_ops[2] = captures[2];
1777 return true;
1778 }
1779next_after_fail70:;
1780 }
1781 }
1782 break;
1783 }
1784 default:;
1785 }
1786}
1787 }
1788 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1789 {
1790 case BIT_NOT_EXPR:
1791 {
1792 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1792, __FUNCTION__)))))
;
1793 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1794 {
1795 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1796 {
1797 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 1797, __FUNCTION__)))))
;
1798 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1799 {
1800 case LSHIFT_EXPR:
1801 {
1802 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1802, __FUNCTION__)))))
;
1803 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 1803, __FUNCTION__)))))
;
1804 if (integer_onep (_q40))
1805 {
1806 {
1807/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1808 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q41, _p1, _q40 };
1809 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1809);
1810 {
1811 res_ops[0] = captures[0];
1812 res_ops[1] = captures[1];
1813 res_ops[2] = captures[2];
1814 return true;
1815 }
1816next_after_fail71:;
1817 }
1818 }
1819 break;
1820 }
1821 default:;
1822 }
1823 break;
1824 }
1825 case LSHIFT_EXPR:
1826 {
1827 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 1827, __FUNCTION__)))))
;
1828 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 1828, __FUNCTION__)))))
;
1829 if (integer_onep (_q30))
1830 {
1831 {
1832/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1833 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
1834 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1834);
1835 {
1836 res_ops[0] = captures[0];
1837 res_ops[1] = captures[1];
1838 res_ops[2] = captures[2];
1839 return true;
1840 }
1841next_after_fail72:;
1842 }
1843 }
1844 break;
1845 }
1846 default:;
1847 }
1848 break;
1849 }
1850 default:;
1851 }
1852 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1853 {
1854 case BIT_NOT_EXPR:
1855 {
1856 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 1856, __FUNCTION__)))))
;
1857 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1858 {
1859 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1860 {
1861 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1861, __FUNCTION__)))))
;
1862 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
1863 {
1864 case LSHIFT_EXPR:
1865 {
1866 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 1866, __FUNCTION__)))))
;
1867 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 1867, __FUNCTION__)))))
;
1868 if (integer_onep (_q50))
1869 {
1870 {
1871/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1872 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q51, _p0, _q50 };
1873 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1873);
1874 {
1875 res_ops[0] = captures[0];
1876 res_ops[1] = captures[1];
1877 res_ops[2] = captures[2];
1878 return true;
1879 }
1880next_after_fail73:;
1881 }
1882 }
1883 break;
1884 }
1885 default:;
1886 }
1887 break;
1888 }
1889 case LSHIFT_EXPR:
1890 {
1891 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1891, __FUNCTION__)))))
;
1892 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 1892, __FUNCTION__)))))
;
1893 if (integer_onep (_q40))
1894 {
1895 {
1896/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1897 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
1898 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1898);
1899 {
1900 res_ops[0] = captures[0];
1901 res_ops[1] = captures[1];
1902 res_ops[2] = captures[2];
1903 return true;
1904 }
1905next_after_fail74:;
1906 }
1907 }
1908 break;
1909 }
1910 default:;
1911 }
1912 break;
1913 }
1914 default:;
1915 }
1916 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1917 {
1918 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1919 {
1920 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1920, __FUNCTION__)))))
;
1921 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1922 {
1923 case LSHIFT_EXPR:
1924 {
1925 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 1925, __FUNCTION__)))))
;
1926 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 1926, __FUNCTION__)))))
;
1927 if (integer_onep (_q30))
1928 {
1929 {
1930/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1931 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
1932 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1932);
1933 {
1934 res_ops[0] = captures[0];
1935 res_ops[1] = captures[1];
1936 res_ops[2] = captures[2];
1937 return true;
1938 }
1939next_after_fail75:;
1940 }
1941 }
1942 break;
1943 }
1944 default:;
1945 }
1946 break;
1947 }
1948 default:;
1949 }
1950 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1951 {
1952 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
1953 {
1954 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 1954, __FUNCTION__)))))
;
1955 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1956 {
1957 case LSHIFT_EXPR:
1958 {
1959 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 1959, __FUNCTION__)))))
;
1960 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 1960, __FUNCTION__)))))
;
1961 if (integer_onep (_q40))
1962 {
1963 {
1964/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1965 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
1966 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1966);
1967 {
1968 res_ops[0] = captures[0];
1969 res_ops[1] = captures[1];
1970 res_ops[2] = captures[2];
1971 return true;
1972 }
1973next_after_fail76:;
1974 }
1975 }
1976 break;
1977 }
1978 default:;
1979 }
1980 break;
1981 }
1982 default:;
1983 }
1984 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1985 {
1986 case LSHIFT_EXPR:
1987 {
1988 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 1988, __FUNCTION__)))))
;
1989 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 1989, __FUNCTION__)))))
;
1990 if (integer_onep (_q20))
1991 {
1992 {
1993/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1994 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q21, _p1, _q20 };
1995 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__1995);
1996 {
1997 res_ops[0] = captures[0];
1998 res_ops[1] = captures[1];
1999 res_ops[2] = captures[2];
2000 return true;
2001 }
2002next_after_fail77:;
2003 }
2004 }
2005 break;
2006 }
2007 default:;
2008 }
2009 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2010 {
2011 case LSHIFT_EXPR:
2012 {
2013 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 2013, __FUNCTION__)))))
;
2014 tree _q31 = TREE_OPERAND (_p1, 1)(*((const_cast<tree*> (tree_operand_check ((_p1), (1), "generic-match.cc"
, 2014, __FUNCTION__)))))
;
2015 if (integer_onep (_q30))
2016 {
2017 {
2018/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2019 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q31, _p0, _q30 };
2020 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2020);
2021 {
2022 res_ops[0] = captures[0];
2023 res_ops[1] = captures[1];
2024 res_ops[2] = captures[2];
2025 return true;
2026 }
2027next_after_fail78:;
2028 }
2029 }
2030 break;
2031 }
2032 default:;
2033 }
2034 break;
2035 }
2036 case BIT_IOR_EXPR:
2037 {
2038 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 2038, __FUNCTION__)))))
;
2039 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 2039, __FUNCTION__)))))
;
2040 {
2041 tree _p0_pops[1];
2042 if (tree_nop_convert (_p0, _p0_pops))
2043 {
2044 tree _q20 = _p0_pops[0];
2045 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2046 {
2047 case BIT_NOT_EXPR:
2048 {
2049 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2049, __FUNCTION__)))))
;
2050 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2051 {
2052 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2053 {
2054 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2054, __FUNCTION__)))))
;
2055 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2056 {
2057 case LSHIFT_EXPR:
2058 {
2059 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2059, __FUNCTION__)))))
;
2060 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 2060, __FUNCTION__)))))
;
2061 if (integer_onep (_q50))
2062 {
2063 {
2064/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2065 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q51, _p1, _q50 };
2066 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2066);
2067 {
2068 res_ops[0] = captures[0];
2069 res_ops[1] = captures[1];
2070 res_ops[2] = captures[2];
2071 return true;
2072 }
2073next_after_fail79:;
2074 }
2075 }
2076 break;
2077 }
2078 default:;
2079 }
2080 break;
2081 }
2082 case LSHIFT_EXPR:
2083 {
2084 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2084, __FUNCTION__)))))
;
2085 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2085, __FUNCTION__)))))
;
2086 if (integer_onep (_q40))
2087 {
2088 {
2089/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2090 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
2091 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2091);
2092 {
2093 res_ops[0] = captures[0];
2094 res_ops[1] = captures[1];
2095 res_ops[2] = captures[2];
2096 return true;
2097 }
2098next_after_fail80:;
2099 }
2100 }
2101 break;
2102 }
2103 default:;
2104 }
2105 break;
2106 }
2107 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2108 {
2109 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2109, __FUNCTION__)))))
;
2110 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2111 {
2112 case LSHIFT_EXPR:
2113 {
2114 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2114, __FUNCTION__)))))
;
2115 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2115, __FUNCTION__)))))
;
2116 if (integer_onep (_q40))
2117 {
2118 {
2119/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2120 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
2121 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2121);
2122 {
2123 res_ops[0] = captures[0];
2124 res_ops[1] = captures[1];
2125 res_ops[2] = captures[2];
2126 return true;
2127 }
2128next_after_fail81:;
2129 }
2130 }
2131 break;
2132 }
2133 default:;
2134 }
2135 break;
2136 }
2137 case LSHIFT_EXPR:
2138 {
2139 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2139, __FUNCTION__)))))
;
2140 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 2140, __FUNCTION__)))))
;
2141 if (integer_onep (_q30))
2142 {
2143 {
2144/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2145 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q31, _p1, _q30 };
2146 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2146);
2147 {
2148 res_ops[0] = captures[0];
2149 res_ops[1] = captures[1];
2150 res_ops[2] = captures[2];
2151 return true;
2152 }
2153next_after_fail82:;
2154 }
2155 }
2156 break;
2157 }
2158 default:;
2159 }
2160}
2161 }
2162 {
2163 tree _p1_pops[1];
2164 if (tree_nop_convert (_p1, _p1_pops))
2165 {
2166 tree _q30 = _p1_pops[0];
2167 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2168 {
2169 case BIT_NOT_EXPR:
2170 {
2171 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2171, __FUNCTION__)))))
;
2172 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2173 {
2174 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2175 {
2176 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2176, __FUNCTION__)))))
;
2177 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
2178 {
2179 case LSHIFT_EXPR:
2180 {
2181 tree _q60 = TREE_OPERAND (_q50, 0)(*((const_cast<tree*> (tree_operand_check ((_q50), (0),
"generic-match.cc", 2181, __FUNCTION__)))))
;
2182 tree _q61 = TREE_OPERAND (_q50, 1)(*((const_cast<tree*> (tree_operand_check ((_q50), (1),
"generic-match.cc", 2182, __FUNCTION__)))))
;
2183 if (integer_onep (_q60))
2184 {
2185 {
2186/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2187 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q61, _p0, _q60 };
2188 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2188);
2189 {
2190 res_ops[0] = captures[0];
2191 res_ops[1] = captures[1];
2192 res_ops[2] = captures[2];
2193 return true;
2194 }
2195next_after_fail83:;
2196 }
2197 }
2198 break;
2199 }
2200 default:;
2201 }
2202 break;
2203 }
2204 case LSHIFT_EXPR:
2205 {
2206 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2206, __FUNCTION__)))))
;
2207 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 2207, __FUNCTION__)))))
;
2208 if (integer_onep (_q50))
2209 {
2210 {
2211/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2212 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
2213 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2213);
2214 {
2215 res_ops[0] = captures[0];
2216 res_ops[1] = captures[1];
2217 res_ops[2] = captures[2];
2218 return true;
2219 }
2220next_after_fail84:;
2221 }
2222 }
2223 break;
2224 }
2225 default:;
2226 }
2227 break;
2228 }
2229 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2230 {
2231 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2231, __FUNCTION__)))))
;
2232 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2233 {
2234 case LSHIFT_EXPR:
2235 {
2236 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2236, __FUNCTION__)))))
;
2237 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 2237, __FUNCTION__)))))
;
2238 if (integer_onep (_q50))
2239 {
2240 {
2241/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2242 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
2243 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2243);
2244 {
2245 res_ops[0] = captures[0];
2246 res_ops[1] = captures[1];
2247 res_ops[2] = captures[2];
2248 return true;
2249 }
2250next_after_fail85:;
2251 }
2252 }
2253 break;
2254 }
2255 default:;
2256 }
2257 break;
2258 }
2259 case LSHIFT_EXPR:
2260 {
2261 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2261, __FUNCTION__)))))
;
2262 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2262, __FUNCTION__)))))
;
2263 if (integer_onep (_q40))
2264 {
2265 {
2266/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2267 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q41, _p0, _q40 };
2268 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2268);
2269 {
2270 res_ops[0] = captures[0];
2271 res_ops[1] = captures[1];
2272 res_ops[2] = captures[2];
2273 return true;
2274 }
2275next_after_fail86:;
2276 }
2277 }
2278 break;
2279 }
2280 default:;
2281 }
2282}
2283 }
2284 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2285 {
2286 case BIT_NOT_EXPR:
2287 {
2288 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 2288, __FUNCTION__)))))
;
2289 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2290 {
2291 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2292 {
2293 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2293, __FUNCTION__)))))
;
2294 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2295 {
2296 case LSHIFT_EXPR:
2297 {
2298 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2298, __FUNCTION__)))))
;
2299 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2299, __FUNCTION__)))))
;
2300 if (integer_onep (_q40))
2301 {
2302 {
2303/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2304 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q41, _p1, _q40 };
2305 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2305);
2306 {
2307 res_ops[0] = captures[0];
2308 res_ops[1] = captures[1];
2309 res_ops[2] = captures[2];
2310 return true;
2311 }
2312next_after_fail87:;
2313 }
2314 }
2315 break;
2316 }
2317 default:;
2318 }
2319 break;
2320 }
2321 case LSHIFT_EXPR:
2322 {
2323 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2323, __FUNCTION__)))))
;
2324 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 2324, __FUNCTION__)))))
;
2325 if (integer_onep (_q30))
2326 {
2327 {
2328/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2329 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
2330 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2330);
2331 {
2332 res_ops[0] = captures[0];
2333 res_ops[1] = captures[1];
2334 res_ops[2] = captures[2];
2335 return true;
2336 }
2337next_after_fail88:;
2338 }
2339 }
2340 break;
2341 }
2342 default:;
2343 }
2344 break;
2345 }
2346 default:;
2347 }
2348 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2349 {
2350 case BIT_NOT_EXPR:
2351 {
2352 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 2352, __FUNCTION__)))))
;
2353 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2354 {
2355 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2356 {
2357 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2357, __FUNCTION__)))))
;
2358 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2359 {
2360 case LSHIFT_EXPR:
2361 {
2362 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2362, __FUNCTION__)))))
;
2363 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 2363, __FUNCTION__)))))
;
2364 if (integer_onep (_q50))
2365 {
2366 {
2367/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2368 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q51, _p0, _q50 };
2369 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2369);
2370 {
2371 res_ops[0] = captures[0];
2372 res_ops[1] = captures[1];
2373 res_ops[2] = captures[2];
2374 return true;
2375 }
2376next_after_fail89:;
2377 }
2378 }
2379 break;
2380 }
2381 default:;
2382 }
2383 break;
2384 }
2385 case LSHIFT_EXPR:
2386 {
2387 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2387, __FUNCTION__)))))
;
2388 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2388, __FUNCTION__)))))
;
2389 if (integer_onep (_q40))
2390 {
2391 {
2392/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2393 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
2394 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2394);
2395 {
2396 res_ops[0] = captures[0];
2397 res_ops[1] = captures[1];
2398 res_ops[2] = captures[2];
2399 return true;
2400 }
2401next_after_fail90:;
2402 }
2403 }
2404 break;
2405 }
2406 default:;
2407 }
2408 break;
2409 }
2410 default:;
2411 }
2412 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2413 {
2414 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2415 {
2416 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 2416, __FUNCTION__)))))
;
2417 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2418 {
2419 case LSHIFT_EXPR:
2420 {
2421 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2421, __FUNCTION__)))))
;
2422 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 2422, __FUNCTION__)))))
;
2423 if (integer_onep (_q30))
2424 {
2425 {
2426/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2427 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
2428 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2428);
2429 {
2430 res_ops[0] = captures[0];
2431 res_ops[1] = captures[1];
2432 res_ops[2] = captures[2];
2433 return true;
2434 }
2435next_after_fail91:;
2436 }
2437 }
2438 break;
2439 }
2440 default:;
2441 }
2442 break;
2443 }
2444 default:;
2445 }
2446 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2447 {
2448 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2449 {
2450 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 2450, __FUNCTION__)))))
;
2451 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2452 {
2453 case LSHIFT_EXPR:
2454 {
2455 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2455, __FUNCTION__)))))
;
2456 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2456, __FUNCTION__)))))
;
2457 if (integer_onep (_q40))
2458 {
2459 {
2460/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2461 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
2462 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2462);
2463 {
2464 res_ops[0] = captures[0];
2465 res_ops[1] = captures[1];
2466 res_ops[2] = captures[2];
2467 return true;
2468 }
2469next_after_fail92:;
2470 }
2471 }
2472 break;
2473 }
2474 default:;
2475 }
2476 break;
2477 }
2478 default:;
2479 }
2480 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2481 {
2482 case LSHIFT_EXPR:
2483 {
2484 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 2484, __FUNCTION__)))))
;
2485 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 2485, __FUNCTION__)))))
;
2486 if (integer_onep (_q20))
2487 {
2488 {
2489/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2490 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q21, _p1, _q20 };
2491 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2491);
2492 {
2493 res_ops[0] = captures[0];
2494 res_ops[1] = captures[1];
2495 res_ops[2] = captures[2];
2496 return true;
2497 }
2498next_after_fail93:;
2499 }
2500 }
2501 break;
2502 }
2503 default:;
2504 }
2505 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2506 {
2507 case LSHIFT_EXPR:
2508 {
2509 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 2509, __FUNCTION__)))))
;
2510 tree _q31 = TREE_OPERAND (_p1, 1)(*((const_cast<tree*> (tree_operand_check ((_p1), (1), "generic-match.cc"
, 2510, __FUNCTION__)))))
;
2511 if (integer_onep (_q30))
2512 {
2513 {
2514/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2515 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q31, _p0, _q30 };
2516 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2516);
2517 {
2518 res_ops[0] = captures[0];
2519 res_ops[1] = captures[1];
2520 res_ops[2] = captures[2];
2521 return true;
2522 }
2523next_after_fail94:;
2524 }
2525 }
2526 break;
2527 }
2528 default:;
2529 }
2530 break;
2531 }
2532 case BIT_XOR_EXPR:
2533 {
2534 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 2534, __FUNCTION__)))))
;
2535 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.cc"
, 2535, __FUNCTION__)))))
;
2536 {
2537 tree _p0_pops[1];
2538 if (tree_nop_convert (_p0, _p0_pops))
2539 {
2540 tree _q20 = _p0_pops[0];
2541 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2542 {
2543 case BIT_NOT_EXPR:
2544 {
2545 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2545, __FUNCTION__)))))
;
2546 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2547 {
2548 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2549 {
2550 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2550, __FUNCTION__)))))
;
2551 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2552 {
2553 case LSHIFT_EXPR:
2554 {
2555 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2555, __FUNCTION__)))))
;
2556 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 2556, __FUNCTION__)))))
;
2557 if (integer_onep (_q50))
2558 {
2559 {
2560/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2561 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q51, _p1, _q50 };
2562 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2562);
2563 {
2564 res_ops[0] = captures[0];
2565 res_ops[1] = captures[1];
2566 res_ops[2] = captures[2];
2567 return true;
2568 }
2569next_after_fail95:;
2570 }
2571 }
2572 break;
2573 }
2574 default:;
2575 }
2576 break;
2577 }
2578 case LSHIFT_EXPR:
2579 {
2580 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2580, __FUNCTION__)))))
;
2581 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2581, __FUNCTION__)))))
;
2582 if (integer_onep (_q40))
2583 {
2584 {
2585/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2586 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
2587 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2587);
2588 {
2589 res_ops[0] = captures[0];
2590 res_ops[1] = captures[1];
2591 res_ops[2] = captures[2];
2592 return true;
2593 }
2594next_after_fail96:;
2595 }
2596 }
2597 break;
2598 }
2599 default:;
2600 }
2601 break;
2602 }
2603 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2604 {
2605 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2605, __FUNCTION__)))))
;
2606 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2607 {
2608 case LSHIFT_EXPR:
2609 {
2610 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2610, __FUNCTION__)))))
;
2611 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2611, __FUNCTION__)))))
;
2612 if (integer_onep (_q40))
2613 {
2614 {
2615/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2616 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _p1, _q40 };
2617 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2617);
2618 {
2619 res_ops[0] = captures[0];
2620 res_ops[1] = captures[1];
2621 res_ops[2] = captures[2];
2622 return true;
2623 }
2624next_after_fail97:;
2625 }
2626 }
2627 break;
2628 }
2629 default:;
2630 }
2631 break;
2632 }
2633 case LSHIFT_EXPR:
2634 {
2635 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2635, __FUNCTION__)))))
;
2636 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 2636, __FUNCTION__)))))
;
2637 if (integer_onep (_q30))
2638 {
2639 {
2640/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2641 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q31, _p1, _q30 };
2642 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2642);
2643 {
2644 res_ops[0] = captures[0];
2645 res_ops[1] = captures[1];
2646 res_ops[2] = captures[2];
2647 return true;
2648 }
2649next_after_fail98:;
2650 }
2651 }
2652 break;
2653 }
2654 default:;
2655 }
2656}
2657 }
2658 {
2659 tree _p1_pops[1];
2660 if (tree_nop_convert (_p1, _p1_pops))
2661 {
2662 tree _q30 = _p1_pops[0];
2663 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2664 {
2665 case BIT_NOT_EXPR:
2666 {
2667 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2667, __FUNCTION__)))))
;
2668 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2669 {
2670 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2671 {
2672 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2672, __FUNCTION__)))))
;
2673 switch (TREE_CODE (_q50)((enum tree_code) (_q50)->base.code))
2674 {
2675 case LSHIFT_EXPR:
2676 {
2677 tree _q60 = TREE_OPERAND (_q50, 0)(*((const_cast<tree*> (tree_operand_check ((_q50), (0),
"generic-match.cc", 2677, __FUNCTION__)))))
;
2678 tree _q61 = TREE_OPERAND (_q50, 1)(*((const_cast<tree*> (tree_operand_check ((_q50), (1),
"generic-match.cc", 2678, __FUNCTION__)))))
;
2679 if (integer_onep (_q60))
2680 {
2681 {
2682/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2683 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q61, _p0, _q60 };
2684 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2684);
2685 {
2686 res_ops[0] = captures[0];
2687 res_ops[1] = captures[1];
2688 res_ops[2] = captures[2];
2689 return true;
2690 }
2691next_after_fail99:;
2692 }
2693 }
2694 break;
2695 }
2696 default:;
2697 }
2698 break;
2699 }
2700 case LSHIFT_EXPR:
2701 {
2702 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2702, __FUNCTION__)))))
;
2703 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 2703, __FUNCTION__)))))
;
2704 if (integer_onep (_q50))
2705 {
2706 {
2707/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2708 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
2709 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2709);
2710 {
2711 res_ops[0] = captures[0];
2712 res_ops[1] = captures[1];
2713 res_ops[2] = captures[2];
2714 return true;
2715 }
2716next_after_fail100:;
2717 }
2718 }
2719 break;
2720 }
2721 default:;
2722 }
2723 break;
2724 }
2725 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2726 {
2727 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2727, __FUNCTION__)))))
;
2728 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2729 {
2730 case LSHIFT_EXPR:
2731 {
2732 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2732, __FUNCTION__)))))
;
2733 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 2733, __FUNCTION__)))))
;
2734 if (integer_onep (_q50))
2735 {
2736 {
2737/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2738 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q51, _p0, _q50 };
2739 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2739);
2740 {
2741 res_ops[0] = captures[0];
2742 res_ops[1] = captures[1];
2743 res_ops[2] = captures[2];
2744 return true;
2745 }
2746next_after_fail101:;
2747 }
2748 }
2749 break;
2750 }
2751 default:;
2752 }
2753 break;
2754 }
2755 case LSHIFT_EXPR:
2756 {
2757 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2757, __FUNCTION__)))))
;
2758 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2758, __FUNCTION__)))))
;
2759 if (integer_onep (_q40))
2760 {
2761 {
2762/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2763 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q41, _p0, _q40 };
2764 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2764);
2765 {
2766 res_ops[0] = captures[0];
2767 res_ops[1] = captures[1];
2768 res_ops[2] = captures[2];
2769 return true;
2770 }
2771next_after_fail102:;
2772 }
2773 }
2774 break;
2775 }
2776 default:;
2777 }
2778}
2779 }
2780 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2781 {
2782 case BIT_NOT_EXPR:
2783 {
2784 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 2784, __FUNCTION__)))))
;
2785 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2786 {
2787 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2788 {
2789 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2789, __FUNCTION__)))))
;
2790 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2791 {
2792 case LSHIFT_EXPR:
2793 {
2794 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2794, __FUNCTION__)))))
;
2795 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2795, __FUNCTION__)))))
;
2796 if (integer_onep (_q40))
2797 {
2798 {
2799/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2800 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q41, _p1, _q40 };
2801 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2801);
2802 {
2803 res_ops[0] = captures[0];
2804 res_ops[1] = captures[1];
2805 res_ops[2] = captures[2];
2806 return true;
2807 }
2808next_after_fail103:;
2809 }
2810 }
2811 break;
2812 }
2813 default:;
2814 }
2815 break;
2816 }
2817 case LSHIFT_EXPR:
2818 {
2819 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2819, __FUNCTION__)))))
;
2820 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 2820, __FUNCTION__)))))
;
2821 if (integer_onep (_q30))
2822 {
2823 {
2824/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2825 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
2826 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2826);
2827 {
2828 res_ops[0] = captures[0];
2829 res_ops[1] = captures[1];
2830 res_ops[2] = captures[2];
2831 return true;
2832 }
2833next_after_fail104:;
2834 }
2835 }
2836 break;
2837 }
2838 default:;
2839 }
2840 break;
2841 }
2842 default:;
2843 }
2844 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2845 {
2846 case BIT_NOT_EXPR:
2847 {
2848 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 2848, __FUNCTION__)))))
;
2849 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2850 {
2851 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2852 {
2853 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2853, __FUNCTION__)))))
;
2854 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
2855 {
2856 case LSHIFT_EXPR:
2857 {
2858 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 2858, __FUNCTION__)))))
;
2859 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 2859, __FUNCTION__)))))
;
2860 if (integer_onep (_q50))
2861 {
2862 {
2863/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2864 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q51, _p0, _q50 };
2865 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2865);
2866 {
2867 res_ops[0] = captures[0];
2868 res_ops[1] = captures[1];
2869 res_ops[2] = captures[2];
2870 return true;
2871 }
2872next_after_fail105:;
2873 }
2874 }
2875 break;
2876 }
2877 default:;
2878 }
2879 break;
2880 }
2881 case LSHIFT_EXPR:
2882 {
2883 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2883, __FUNCTION__)))))
;
2884 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2884, __FUNCTION__)))))
;
2885 if (integer_onep (_q40))
2886 {
2887 {
2888/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2889 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
2890 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2890);
2891 {
2892 res_ops[0] = captures[0];
2893 res_ops[1] = captures[1];
2894 res_ops[2] = captures[2];
2895 return true;
2896 }
2897next_after_fail106:;
2898 }
2899 }
2900 break;
2901 }
2902 default:;
2903 }
2904 break;
2905 }
2906 default:;
2907 }
2908 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2909 {
2910 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2911 {
2912 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 2912, __FUNCTION__)))))
;
2913 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
2914 {
2915 case LSHIFT_EXPR:
2916 {
2917 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 2917, __FUNCTION__)))))
;
2918 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 2918, __FUNCTION__)))))
;
2919 if (integer_onep (_q30))
2920 {
2921 {
2922/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2923 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _p1, _q30 };
2924 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2924);
2925 {
2926 res_ops[0] = captures[0];
2927 res_ops[1] = captures[1];
2928 res_ops[2] = captures[2];
2929 return true;
2930 }
2931next_after_fail107:;
2932 }
2933 }
2934 break;
2935 }
2936 default:;
2937 }
2938 break;
2939 }
2940 default:;
2941 }
2942 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
2943 {
2944 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2945 {
2946 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 2946, __FUNCTION__)))))
;
2947 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
2948 {
2949 case LSHIFT_EXPR:
2950 {
2951 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 2951, __FUNCTION__)))))
;
2952 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 2952, __FUNCTION__)))))
;
2953 if (integer_onep (_q40))
2954 {
2955 {
2956/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2957 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q41, _p0, _q40 };
2958 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2958);
2959 {
2960 res_ops[0] = captures[0];
2961 res_ops[1] = captures[1];
2962 res_ops[2] = captures[2];
2963 return true;
2964 }
2965next_after_fail108:;
2966 }
2967 }
2968 break;
2969 }
2970 default:;
2971 }
2972 break;
2973 }
2974 default:;
2975 }
2976 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
2977 {
2978 case LSHIFT_EXPR:
2979 {
2980 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 2980, __FUNCTION__)))))
;
2981 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 2981, __FUNCTION__)))))
;
2982 if (integer_onep (_q20))
2983 {
2984 {
2985/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2986 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q21, _p1, _q20 };
2987 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__2987);
2988 {
2989 res_ops[0] = captures[0];
2990 res_ops[1] = captures[1];
2991 res_ops[2] = captures[2];
2992 return true;
2993 }
2994next_after_fail109:;
2995 }
2996 }
2997 break;
2998 }
2999 default:;
3000 }
3001 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
3002 {
3003 case LSHIFT_EXPR:
3004 {
3005 tree _q30 = TREE_OPERAND (_p1, 0)(*((const_cast<tree*> (tree_operand_check ((_p1), (0), "generic-match.cc"
, 3005, __FUNCTION__)))))
;
3006 tree _q31 = TREE_OPERAND (_p1, 1)(*((const_cast<tree*> (tree_operand_check ((_p1), (1), "generic-match.cc"
, 3006, __FUNCTION__)))))
;
3007 if (integer_onep (_q30))
3008 {
3009 {
3010/* #line 8377 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3011 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _q31, _p0, _q30 };
3012 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8377, __FILE__"generic-match.cc", __LINE__3012);
3013 {
3014 res_ops[0] = captures[0];
3015 res_ops[1] = captures[1];
3016 res_ops[2] = captures[2];
3017 return true;
3018 }
3019next_after_fail110:;
3020 }
3021 }
3022 break;
3023 }
3024 default:;
3025 }
3026 break;
3027 }
3028 case BIT_NOT_EXPR:
3029 {
3030 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.cc"
, 3030, __FUNCTION__)))))
;
3031 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
3032 {
3033 case BIT_XOR_EXPR:
3034 {
3035 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.cc"
, 3035, __FUNCTION__)))))
;
3036 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.cc"
, 3036, __FUNCTION__)))))
;
3037 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
3038 {
3039 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3040 {
3041 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 3041, __FUNCTION__)))))
;
3042 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
3043 {
3044 case LSHIFT_EXPR:
3045 {
3046 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 3046, __FUNCTION__)))))
;
3047 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 3047, __FUNCTION__)))))
;
3048 if (integer_onep (_q40))
3049 {
3050 {
3051/* #line 8382 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3052 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q41, _q21, _q40 };
3053 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8382, __FILE__"generic-match.cc", __LINE__3053);
3054 {
3055 res_ops[0] = captures[0];
3056 res_ops[1] = captures[1];
3057 res_ops[2] = captures[2];
3058 return true;
3059 }
3060next_after_fail111:;
3061 }
3062 }
3063 break;
3064 }
3065 default:;
3066 }
3067 break;
3068 }
3069 case LSHIFT_EXPR:
3070 {
3071 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 3071, __FUNCTION__)))))
;
3072 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 3072, __FUNCTION__)))))
;
3073 if (integer_onep (_q30))
3074 {
3075 {
3076/* #line 8382 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3077 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _q31, _q21, _q30 };
3078 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8382, __FILE__"generic-match.cc", __LINE__3078);
3079 {
3080 res_ops[0] = captures[0];
3081 res_ops[1] = captures[1];
3082 res_ops[2] = captures[2];
3083 return true;
3084 }
3085next_after_fail112:;
3086 }
3087 }
3088 break;
3089 }
3090 default:;
3091 }
3092 break;
3093 }
3094 default:;
3095 }
3096 {
3097 tree _p0_pops[1];
3098 if (tree_nop_convert (_p0, _p0_pops))
3099 {
3100 tree _q20 = _p0_pops[0];
3101 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
3102 {
3103 case BIT_XOR_EXPR:
3104 {
3105 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.cc", 3105, __FUNCTION__)))))
;
3106 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.cc", 3106, __FUNCTION__)))))
;
3107 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
3108 {
3109 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
3110 {
3111 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 3111, __FUNCTION__)))))
;
3112 switch (TREE_CODE (_q40)((enum tree_code) (_q40)->base.code))
3113 {
3114 case LSHIFT_EXPR:
3115 {
3116 tree _q50 = TREE_OPERAND (_q40, 0)(*((const_cast<tree*> (tree_operand_check ((_q40), (0),
"generic-match.cc", 3116, __FUNCTION__)))))
;
3117 tree _q51 = TREE_OPERAND (_q40, 1)(*((const_cast<tree*> (tree_operand_check ((_q40), (1),
"generic-match.cc", 3117, __FUNCTION__)))))
;
3118 if (integer_onep (_q50))
3119 {
3120 {
3121/* #line 8382 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3122 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q51, _q31, _q50 };
3123 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8382, __FILE__"generic-match.cc", __LINE__3123);
3124 {
3125 res_ops[0] = captures[0];
3126 res_ops[1] = captures[1];
3127 res_ops[2] = captures[2];
3128 return true;
3129 }
3130next_after_fail113:;
3131 }
3132 }
3133 break;
3134 }
3135 default:;
3136 }
3137 break;
3138 }
3139 case LSHIFT_EXPR:
3140 {
3141 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.cc", 3141, __FUNCTION__)))))
;
3142 tree _q41 = TREE_OPERAND (_q30, 1)(*((const_cast<tree*> (tree_operand_check ((_q30), (1),
"generic-match.cc", 3142, __FUNCTION__)))))
;
3143 if (integer_onep (_q40))
3144 {
3145 {
3146/* #line 8382 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3147 tree captures[4] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q41, _q31, _q40 };
3148 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 8382, __FILE__"generic-match.cc", __LINE__3148);
3149 {
3150 res_ops[0] = captures[0];
3151 res_ops[1] = captures[1];
3152 res_ops[2] = captures[2];
3153 return true;
3154 }
3155next_after_fail114:;
3156 }
3157 }
3158 break;
3159 }
3160 default:;
3161 }
3162 break;
3163 }
3164 default:;
3165 }
3166}
3167 }
3168 break;
3169 }
3170 default:;
3171 }
3172 return false;
3173}
3174
3175static tree
3176generic_simplify_1 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3177 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3178, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)))
3179{
3180/* #line 428 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3181 if (!ALL_FRACT_MODE_P (TYPE_MODE (type))((((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((type), (tcc_type), "generic-match.cc", 3181, __FUNCTION__)
))->base.code) == VECTOR_TYPE) ? vector_type_mode (type) :
(type)->type_common.mode)]) == MODE_FRACT || ((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((type), (
tcc_type), "generic-match.cc", 3181, __FUNCTION__)))->base
.code) == VECTOR_TYPE) ? vector_type_mode (type) : (type)->
type_common.mode)]) == MODE_VECTOR_FRACT) || (((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((type), (
tcc_type), "generic-match.cc", 3181, __FUNCTION__)))->base
.code) == VECTOR_TYPE) ? vector_type_mode (type) : (type)->
type_common.mode)]) == MODE_UFRACT || ((enum mode_class) mode_class
[((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.cc"
, 3181, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)]) == MODE_VECTOR_UFRACT
))
3182 && !integer_zerop (captures[0])
3183 && (!flag_non_call_exceptionsglobal_options.x_flag_non_call_exceptions || tree_expr_nonzero_p (captures[0]))
3184)
3185 {
3186 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail115;
3187 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 431, __FILE__"generic-match.cc", __LINE__3187);
3188 {
3189 tree _r;
3190 _r = build_one_cst (type);
3191 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3191, __FUNCTION__
))->base.side_effects_flag)
)
3192 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3193 return _r;
3194 }
3195next_after_fail115:;
3196 }
3197 return NULL_TREE(tree) nullptr;
3198}
3199
3200static tree
3201generic_simplify_2 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3202 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3203, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3204{
3205/* #line 5191 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3206 if (! FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 3206, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE) || ((((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 3206, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.cc", 3206, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.cc", 3206, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 3206, __FUNCTION__
))->typed.type))->base.code) == REAL_TYPE)))
3207 || ! tree_expr_maybe_nan_p (captures[0])
3208)
3209 {
3210 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail116;
3211 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5193, __FILE__"generic-match.cc", __LINE__3211);
3212 {
3213 tree _r;
3214 _r = constant_boolean_node (true, type);
3215 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3215, __FUNCTION__
))->base.side_effects_flag)
)
3216 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3217 return _r;
3218 }
3219next_after_fail116:;
3220 }
3221 else
3222 {
3223/* #line 5194 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3224 if (cmp != EQ_EXPR
3225 && (! FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 3225, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE) || ((((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 3225, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.cc", 3225, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.cc", 3225, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 3225, __FUNCTION__
))->typed.type))->base.code) == REAL_TYPE)))
3226 || ! flag_trapping_mathglobal_options.x_flag_trapping_math)
3227)
3228 {
3229 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail117;
3230 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5198, __FILE__"generic-match.cc", __LINE__3230);
3231 {
3232 tree res_op0;
3233 res_op0 = unshare_expr (captures[0]);
3234 tree res_op1;
3235 res_op1 = captures[0];
3236 tree _r;
3237 _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
3238 return _r;
3239 }
3240next_after_fail117:;
3241 }
3242 }
3243 return NULL_TREE(tree) nullptr;
3244}
3245
3246static tree
3247generic_simplify_3 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3248 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3249, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3250{
3251 {
3252/* #line 4745 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3253 tree from_type = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 3253, __FUNCTION__))->typed.type)
, to_type = TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 3253, __FUNCTION__))->typed.type)
;
3254/* #line 4746 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3255 if (types_match (from_type, to_type)
3256 || (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3256, __FUNCTION__))->base.u.bits.unsigned_flag)
3257 && !TYPE_UNSIGNED (to_type)((tree_class_check ((to_type), (tcc_type), "generic-match.cc"
, 3257, __FUNCTION__))->base.u.bits.unsigned_flag)
3258 && TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3258, __FUNCTION__))->type_common.precision)
== TYPE_PRECISION (to_type)((tree_class_check ((to_type), (tcc_type), "generic-match.cc"
, 3258, __FUNCTION__))->type_common.precision)
3259 && integer_zerop (captures[1])
3260 && (cmp == LT_EXPR || cmp == GE_EXPR))
3261)
3262 {
3263 {
3264/* #line 4753 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3265 wi::overflow_type overflow = wi::OVF_NONE;
3266 enum tree_code code, cmp_code = cmp;
3267 wide_int real_c1;
3268 wide_int c1 = wi::to_wide (captures[1]);
3269 wide_int c2 = wi::to_wide (captures[2]);
3270 wide_int c3 = wi::to_wide (captures[3]);
3271 signop sgn = TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3271, __FUNCTION__))->base.u.bits.unsigned_flag))
;
3272 if (!types_match (from_type, to_type))
3273 {
3274 if (cmp_code == LT_EXPR)
3275 cmp_code = GT_EXPR;
3276 if (cmp_code == GE_EXPR)
3277 cmp_code = LE_EXPR;
3278 c1 = wi::max_value (to_type);
3279 }
3280 if (op == PLUS_EXPR)
3281 real_c1 = wi::sub (c3, c2, sgn, &overflow);
3282 else
3283 real_c1 = wi::add (c3, c2, sgn, &overflow);
3284 code = cmp_code;
3285 if (!overflow || !TYPE_OVERFLOW_UNDEFINED (from_type)((((enum tree_code) (from_type)->base.code) == POINTER_TYPE
|| ((enum tree_code) (from_type)->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((from_type), "generic-match.cc", 3285, __FUNCTION__))->base
.u.bits.unsigned_flag && !global_options.x_flag_wrapv
&& !global_options.x_flag_trapv))
)
3286 {
3287 if (!wi::cmp (wi::sub (real_c1, 1, sgn, &overflow), c1, sgn)
3288 && !overflow)
3289 {
3290 if (cmp_code == LE_EXPR)
3291 code = LT_EXPR;
3292 if (cmp_code == GT_EXPR)
3293 code = GE_EXPR;
3294 }
3295 if (!wi::cmp (wi::add (real_c1, 1, sgn, &overflow), c1, sgn)
3296 && !overflow)
3297 {
3298 if (cmp_code == LT_EXPR)
3299 code = LE_EXPR;
3300 if (cmp_code == GE_EXPR)
3301 code = GT_EXPR;
3302 }
3303 if (code != cmp_code || !wi::cmp (real_c1, c1, sgn))
3304 {
3305 if (cmp_code == LT_EXPR || cmp_code == LE_EXPR)
3306 code = MIN_EXPR;
3307 if (cmp_code == GT_EXPR || cmp_code == GE_EXPR)
3308 code = MAX_EXPR;
3309 }
3310 }
3311/* #line 4817 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3312 if (code == MAX_EXPR
3313)
3314 {
3315 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3315, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail118;
3316 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3316, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail118;
3317 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3317, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail118;
3318 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.cc", 3318, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail118;
3319 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail118;
3320 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4818, __FILE__"generic-match.cc", __LINE__3320);
3321 {
3322 tree res_op0;
3323 {
3324 tree _o1[2], _r1;
3325 _o1[0] = captures[0];
3326 _o1[1] = wide_int_to_tree (from_type, real_c1);
3327 _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3327, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3328 res_op0 = _r1;
3329 }
3330 tree res_op1;
3331 res_op1 = wide_int_to_tree (from_type, c2);
3332 tree _r;
3333 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3334 return _r;
3335 }
3336next_after_fail118:;
3337 }
3338 else
3339 {
3340/* #line 4820 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3341 if (code == MIN_EXPR
3342)
3343 {
3344 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3344, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail119;
3345 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3345, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail119;
3346 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3346, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail119;
3347 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.cc", 3347, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail119;
3348 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail119;
3349 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4821, __FILE__"generic-match.cc", __LINE__3349);
3350 {
3351 tree res_op0;
3352 {
3353 tree _o1[2], _r1;
3354 _o1[0] = captures[0];
3355 _o1[1] = wide_int_to_tree (from_type, real_c1);
3356 _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3356, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3357 res_op0 = _r1;
3358 }
3359 tree res_op1;
3360 res_op1 = wide_int_to_tree (from_type, c2);
3361 tree _r;
3362 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3363 return _r;
3364 }
3365next_after_fail119:;
3366 }
3367 }
3368 }
3369 }
3370 }
3371 return NULL_TREE(tree) nullptr;
3372}
3373
3374static tree
3375generic_simplify_4 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3376 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3377, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)))
3378{
3379/* #line 444 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3380 if ((INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
|| VECTOR_INTEGER_TYPE_P (type)((((enum tree_code) (type)->base.code) == VECTOR_TYPE) &&
((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.cc", 3380, __FUNCTION__))->typed.type))->
base.code) == INTEGER_TYPE)
)
3381 && TYPE_OVERFLOW_UNDEFINED (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? !
global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((type), "generic-match.cc", 3381, __FUNCTION__))->base.u
.bits.unsigned_flag && !global_options.x_flag_wrapv &&
!global_options.x_flag_trapv))
3382 && !integer_zerop (captures[0])
3383 && (!flag_non_call_exceptionsglobal_options.x_flag_non_call_exceptions || tree_expr_nonzero_p (captures[0]))
3384)
3385 {
3386 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail120;
3387 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 448, __FILE__"generic-match.cc", __LINE__3387);
3388 {
3389 tree _r;
3390 _r = build_minus_one_cst (type);
3391 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3391, __FUNCTION__
))->base.side_effects_flag)
)
3392 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3393 return _r;
3394 }
3395next_after_fail120:;
3396 }
3397 return NULL_TREE(tree) nullptr;
3398}
3399
3400static tree
3401generic_simplify_5 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3402 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
3403, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (icmp)icmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (ncmp)ncmp __attribute__ ((__unused__)))
3404{
3405/* #line 5060 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3406 if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE)
3407 || (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.cc", 3407
, __FUNCTION__))->type_common.precision)
== 1)
3408)
3409 {
3410 {
3411/* #line 5066 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3412 enum tree_code ic = invert_tree_comparison
3413 (cmp, HONOR_NANS (captures[0]));
3414/* #line 5068 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3415 if (ic == icmp
3416)
3417 {
3418 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail121;
3419 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5069, __FILE__"generic-match.cc", __LINE__3419);
3420 {
3421 tree res_op0;
3422 res_op0 = captures[0];
3423 tree res_op1;
3424 res_op1 = captures[1];
3425 tree _r;
3426 _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
3427 return _r;
3428 }
3429next_after_fail121:;
3430 }
3431 else
3432 {
3433/* #line 5070 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3434 if (ic == ncmp
3435)
3436 {
3437 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail122;
3438 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5071, __FILE__"generic-match.cc", __LINE__3438);
3439 {
3440 tree res_op0;
3441 res_op0 = captures[0];
3442 tree res_op1;
3443 res_op1 = captures[1];
3444 tree _r;
3445 _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
3446 return _r;
3447 }
3448next_after_fail122:;
3449 }
3450 }
3451 }
3452 }
3453 return NULL_TREE(tree) nullptr;
3454}
3455
3456static tree
3457generic_simplify_6 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3458 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3459)
3460{
3461/* #line 785 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3462 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
3463)
3464 {
3465 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 3465, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail123;
3466 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail123;
3467 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 786, __FILE__"generic-match.cc", __LINE__3467);
3468 {
3469 tree res_op0;
3470 res_op0 = unshare_expr (captures[1]);
3471 tree res_op1;
3472 {
3473 tree _o1[2], _r1;
3474 _o1[0] = captures[4];
3475 _o1[1] = captures[1];
3476 _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3476, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3477 res_op1 = _r1;
3478 }
3479 tree _r;
3480 _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
3481 return _r;
3482 }
3483next_after_fail123:;
3484 }
3485 return NULL_TREE(tree) nullptr;
3486}
3487
3488static tree
3489generic_simplify_7 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3490 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3491, const combined_fn ARG_UNUSED (cond_op)cond_op __attribute__ ((__unused__)))
3492{
3493 {
3494/* #line 7947 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3495 tree op_type = TREE_TYPE (captures[5])((contains_struct_check ((captures[5]), (TS_TYPED), "generic-match.cc"
, 3495, __FUNCTION__))->typed.type)
;
3496/* #line 7948 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3497 if (inverse_conditions_p (captures[0], captures[2])
3498 && element_precision (type) == element_precision (op_type)
3499)
3500 {
3501 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail124;
3502 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 7950, __FILE__"generic-match.cc", __LINE__3502);
3503 {
3504 tree res_op0;
3505 {
3506 tree _o1[4], _r1;
3507 _o1[0] = captures[2];
3508 _o1[1] = captures[3];
3509 _o1[2] = captures[4];
3510 {
3511 tree _o2[1], _r2;
3512 _o2[0] = captures[1];
3513 _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
3514 _o1[3] = _r2;
3515 }
3516 _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1])((contains_struct_check ((_o1[1]), (TS_TYPED), "generic-match.cc"
, 3516, __FUNCTION__))->typed.type)
, 4, _o1[0], _o1[1], _o1[2], _o1[3]);
3517 if (!_r1)
3518 goto next_after_fail124;
3519 res_op0 = _r1;
3520 }
3521 tree _r;
3522 _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
3523 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3523, __FUNCTION__
))->base.side_effects_flag)
)
3524 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3525 if (TREE_SIDE_EFFECTS (captures[5])((non_type_check ((captures[5]), "generic-match.cc", 3525, __FUNCTION__
))->base.side_effects_flag)
)
3526 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[5]), _r);
3527 return _r;
3528 }
3529next_after_fail124:;
3530 }
3531 }
3532 return NULL_TREE(tree) nullptr;
3533}
3534
3535static tree
3536generic_simplify_8 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3537 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3538, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3539{
3540 {
3541/* #line 4662 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3542 tree from_type = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 3542, __FUNCTION__))->typed.type)
;
3543 tree c1_type = TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 3543, __FUNCTION__))->typed.type)
, c2_type = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 3543, __FUNCTION__))->typed.type)
;
3544 enum tree_code code = ERROR_MARK;
3545 if (INTEGRAL_TYPE_P (from_type)(((enum tree_code) (from_type)->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (from_type)->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (from_type)->base.code) == INTEGER_TYPE
)
3546 && int_fits_type_p (captures[2], from_type)
3547 && (types_match (c1_type, from_type)
3548 || (TYPE_PRECISION (c1_type)((tree_class_check ((c1_type), (tcc_type), "generic-match.cc"
, 3548, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3548, __FUNCTION__))->type_common.precision)
3549 && (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3549, __FUNCTION__))->base.u.bits.unsigned_flag)
3550 || TYPE_SIGN (c1_type)((signop) ((tree_class_check ((c1_type), (tcc_type), "generic-match.cc"
, 3550, __FUNCTION__))->base.u.bits.unsigned_flag))
== TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3550, __FUNCTION__))->base.u.bits.unsigned_flag))
)))
3551 && (types_match (c2_type, from_type)
3552 || (TYPE_PRECISION (c2_type)((tree_class_check ((c2_type), (tcc_type), "generic-match.cc"
, 3552, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3552, __FUNCTION__))->type_common.precision)
3553 && (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3553, __FUNCTION__))->base.u.bits.unsigned_flag)
3554 || TYPE_SIGN (c2_type)((signop) ((tree_class_check ((c2_type), (tcc_type), "generic-match.cc"
, 3554, __FUNCTION__))->base.u.bits.unsigned_flag))
== TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.cc"
, 3554, __FUNCTION__))->base.u.bits.unsigned_flag))
))))
3555 {
3556 if (cmp != EQ_EXPR)
3557 {
3558 if (wi::to_widest (captures[1]) == (wi::to_widest (captures[2]) - 1))
3559 {
3560 if (cmp == LE_EXPR)
3561 code = LT_EXPR;
3562 if (cmp == GT_EXPR)
3563 code = GE_EXPR;
3564 }
3565 if (wi::to_widest (captures[1]) == (wi::to_widest (captures[2]) + 1))
3566 {
3567 if (cmp == LT_EXPR)
3568 code = LE_EXPR;
3569 if (cmp == GE_EXPR)
3570 code = GT_EXPR;
3571 }
3572 if (code != ERROR_MARK
3573 || wi::to_widest (captures[2]) == wi::to_widest (captures[1]))
3574 {
3575 if (cmp == LT_EXPR || cmp == LE_EXPR)
3576 code = MIN_EXPR;
3577 if (cmp == GT_EXPR || cmp == GE_EXPR)
3578 code = MAX_EXPR;
3579 }
3580 }
3581 else if (int_fits_type_p (captures[1], from_type))
3582 code = EQ_EXPR;
3583 }
3584/* #line 4713 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3585 if (code == MAX_EXPR
3586)
3587 {
3588 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3588, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail125;
3589 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3589, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail125;
3590 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3590, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail125;
3591 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail125;
3592 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4714, __FILE__"generic-match.cc", __LINE__3592);
3593 {
3594 tree res_op0;
3595 {
3596 tree _o1[2], _r1;
3597 _o1[0] = captures[0];
3598 {
3599 tree _o2[1], _r2;
3600 _o2[0] = captures[2];
3601 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc"
, 3601, __FUNCTION__))->typed.type)
!= TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3601, __FUNCTION__))->typed.type)
)
3602 _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3602, __FUNCTION__))->typed.type)
, _o2[0]);
3603 else
3604 _r2 = _o2[0];
3605 _o1[1] = _r2;
3606 }
3607 _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3607, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3608 res_op0 = _r1;
3609 }
3610 tree _r;
3611 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3612 return _r;
3613 }
3614next_after_fail125:;
3615 }
3616 else
3617 {
3618/* #line 4715 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3619 if (code == MIN_EXPR
3620)
3621 {
3622 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3622, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail126;
3623 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3623, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail126;
3624 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3624, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail126;
3625 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail126;
3626 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4716, __FILE__"generic-match.cc", __LINE__3626);
3627 {
3628 tree res_op0;
3629 {
3630 tree _o1[2], _r1;
3631 _o1[0] = captures[0];
3632 {
3633 tree _o2[1], _r2;
3634 _o2[0] = captures[2];
3635 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc"
, 3635, __FUNCTION__))->typed.type)
!= TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3635, __FUNCTION__))->typed.type)
)
3636 _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3636, __FUNCTION__))->typed.type)
, _o2[0]);
3637 else
3638 _r2 = _o2[0];
3639 _o1[1] = _r2;
3640 }
3641 _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3641, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3642 res_op0 = _r1;
3643 }
3644 tree _r;
3645 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3646 return _r;
3647 }
3648next_after_fail126:;
3649 }
3650 else
3651 {
3652/* #line 4717 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3653 if (code == EQ_EXPR
3654)
3655 {
3656 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3656, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail127;
3657 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3657, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail127;
3658 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3658, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail127;
3659 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail127;
3660 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4718, __FILE__"generic-match.cc", __LINE__3660);
3661 {
3662 if (! tree_invariant_p (captures[1])) goto next_after_fail127;
3663 tree res_op0;
3664 {
3665 tree _o1[3], _r1;
3666 {
3667 tree _o2[2], _r2;
3668 _o2[0] = captures[0];
3669 {
3670 tree _o3[1], _r3;
3671 _o3[0] = unshare_expr (captures[1]);
3672 if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.cc"
, 3672, __FUNCTION__))->typed.type)
!= TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc"
, 3672, __FUNCTION__))->typed.type)
)
3673 _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc"
, 3673, __FUNCTION__))->typed.type)
, _o3[0]);
3674 else
3675 _r3 = _o3[0];
3676 _o2[1] = _r3;
3677 }
3678 _r2 = fold_build2_loc (loc, EQ_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], _o2[0], _o2[1]);
3679 _o1[0] = _r2;
3680 }
3681 {
3682 tree _o2[1], _r2;
3683 _o2[0] = captures[1];
3684 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc"
, 3684, __FUNCTION__))->typed.type)
!= from_type)
3685 _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
3686 else
3687 _r2 = _o2[0];
3688 _o1[1] = _r2;
3689 }
3690 {
3691 tree _o2[1], _r2;
3692 _o2[0] = captures[2];
3693 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc"
, 3693, __FUNCTION__))->typed.type)
!= from_type)
3694 _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
3695 else
3696 _r2 = _o2[0];
3697 _o1[2] = _r2;
3698 }
3699 _r1 = fold_build3_loc (loc, COND_EXPR, TREE_TYPE (_o1[1])((contains_struct_check ((_o1[1]), (TS_TYPED), "generic-match.cc"
, 3699, __FUNCTION__))->typed.type)
, _o1[0], _o1[1], _o1[2]);
3700 res_op0 = _r1;
3701 }
3702 tree _r;
3703 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3704 return _r;
3705 }
3706next_after_fail127:;
3707 }
3708 }
3709 }
3710 }
3711 return NULL_TREE(tree) nullptr;
3712}
3713
3714static tree
3715generic_simplify_9 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3716 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3717, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3718{
3719 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 3719, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail128;
3720 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail128;
3721 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1607, __FILE__"generic-match.cc", __LINE__3721);
3722 {
3723 tree _r;
3724 _r = captures[0];
3725 return _r;
3726 }
3727next_after_fail128:;
3728 return NULL_TREE(tree) nullptr;
3729}
3730
3731static tree
3732generic_simplify_10 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3733 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3734, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)))
3735{
3736 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail129;
3737 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1402, __FILE__"generic-match.cc", __LINE__3737);
3738 {
3739 tree res_op0;
3740 res_op0 = captures[0];
3741 tree res_op1;
3742 {
3743 tree _o1[1], _r1;
3744 _o1[0] = captures[2];
3745 _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3745, __FUNCTION__))->typed.type)
, _o1[0]);
3746 res_op1 = _r1;
3747 }
3748 tree _r;
3749 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
3750 return _r;
3751 }
3752next_after_fail129:;
3753 return NULL_TREE(tree) nullptr;
3754}
3755
3756static tree
3757generic_simplify_11 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3758 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3759, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3760{
3761/* #line 2292 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3762 if (!TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 3762, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 3762, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 3762, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) && !((((enum tree_code
) (((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 3762, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 3762, __FUNCTION__))->typed
.type))->base.code) == REFERENCE_TYPE) ? global_options.x_flag_wrapv_pointer
: ((any_integral_type_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.cc", 3762, __FUNCTION__))->
typed.type)), "generic-match.cc", 3762, __FUNCTION__))->base
.u.bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
3763)
3764 {
3765 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail130;
3766 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2293, __FILE__"generic-match.cc", __LINE__3766);
3767 {
3768 tree res_op0;
3769 res_op0 = captures[1];
3770 tree res_op1;
3771 res_op1 = captures[3];
3772 tree _r;
3773 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3774 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3774, __FUNCTION__
))->base.side_effects_flag)
)
3775 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3776 return _r;
3777 }
3778next_after_fail130:;
3779 }
3780 return NULL_TREE(tree) nullptr;
3781}
3782
3783static tree
3784generic_simplify_12 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3785 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3786, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (bswap)bswap __attribute__ ((__unused__)))
3787{
3788 {
3789/* #line 4331 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3790 tree ctype = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 3790, __FUNCTION__))->typed.type)
;
3791 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail131;
3792 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4332, __FILE__"generic-match.cc", __LINE__3792);
3793 {
3794 tree res_op0;
3795 {
3796 tree _o1[1], _r1;
3797 _o1[0] = captures[1];
3798 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3798, __FUNCTION__))->typed.type)
!= ctype)
3799 _r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
3800 else
3801 _r1 = _o1[0];
3802 res_op0 = _r1;
3803 }
3804 tree res_op1;
3805 {
3806 tree _o1[1], _r1;
3807 _o1[0] = captures[2];
3808 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3808, __FUNCTION__))->typed.type)
!= ctype)
3809 _r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
3810 else
3811 _r1 = _o1[0];
3812 res_op1 = _r1;
3813 }
3814 tree _r;
3815 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
3816 return _r;
3817 }
3818next_after_fail131:;
3819 }
3820 return NULL_TREE(tree) nullptr;
3821}
3822
3823static tree
3824generic_simplify_13 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3825 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3826)
3827{
3828 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail132;
3829 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 7114, __FILE__"generic-match.cc", __LINE__3829);
3830 {
3831 tree _r;
3832 _r = captures[0];
3833 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3833, __FUNCTION__
))->base.side_effects_flag)
)
3834 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3835 return _r;
3836 }
3837next_after_fail132:;
3838 return NULL_TREE(tree) nullptr;
3839}
3840
3841static tree
3842generic_simplify_14 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3843 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3844, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3845{
3846 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail133;
3847 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5730, __FILE__"generic-match.cc", __LINE__3847);
3848 {
3849 tree res_op0;
3850 res_op0 = captures[0];
3851 tree res_op1;
3852 res_op1 = captures[1];
3853 tree _r;
3854 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3855 return _r;
3856 }
3857next_after_fail133:;
3858 return NULL_TREE(tree) nullptr;
3859}
3860
3861static tree
3862generic_simplify_15 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3863 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3864)
3865{
3866 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail134;
3867 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1412, __FILE__"generic-match.cc", __LINE__3867);
3868 {
3869 tree res_op0;
3870 res_op0 = captures[0];
3871 tree _r;
3872 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
3873 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3873, __FUNCTION__
))->base.side_effects_flag)
)
3874 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3875 return _r;
3876 }
3877next_after_fail134:;
3878 return NULL_TREE(tree) nullptr;
3879}
3880
3881static tree
3882generic_simplify_16 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3883 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3884, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)))
3885{
3886/* #line 1862 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3887 if (!CONSTANT_CLASS_P (captures[0])(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (captures[0])->base.code))] == tcc_constant)
3888)
3889 {
3890 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail135;
3891 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1865, __FILE__"generic-match.cc", __LINE__3891);
3892 {
3893 tree res_op0;
3894 res_op0 = captures[0];
3895 tree res_op1;
3896 {
3897 tree _o1[2], _r1;
3898 _o1[0] = captures[1];
3899 _o1[1] = captures[2];
3900 _r1 = fold_build2_loc (loc, bitop, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3900, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3901 res_op1 = _r1;
3902 }
3903 tree _r;
3904 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
3905 return _r;
3906 }
3907next_after_fail135:;
3908 }
3909 else
3910 {
3911 {
3912/* #line 1874 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3913 tree cst1 = const_binop (bitop, type, captures[0], captures[2]);
3914/* #line 1875 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3915 if (cst1
3916)
3917 {
3918 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3918, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail136;
3919 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3919, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail136;
3920 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail136;
3921 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1876, __FILE__"generic-match.cc", __LINE__3921);
3922 {
3923 tree res_op0;
3924 res_op0 = captures[1];
3925 tree res_op1;
3926 res_op1 = cst1;
3927 tree _r;
3928 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
3929 return _r;
3930 }
3931next_after_fail136:;
3932 }
3933 else
3934 {
3935 {
3936/* #line 1877 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3937 tree cst2 = const_binop (bitop, type, captures[1], captures[2]);
3938/* #line 1878 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3939 if (cst2
3940)
3941 {
3942 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 3942, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail137;
3943 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 3943, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail137;
3944 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 3944, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail137;
3945 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail137;
3946 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1879, __FILE__"generic-match.cc", __LINE__3946);
3947 {
3948 tree res_op0;
3949 res_op0 = captures[0];
3950 tree res_op1;
3951 res_op1 = cst2;
3952 tree _r;
3953 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
3954 return _r;
3955 }
3956next_after_fail137:;
3957 }
3958 }
3959 }
3960 }
3961 }
3962 return NULL_TREE(tree) nullptr;
3963}
3964
3965static tree
3966generic_simplify_17 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3967 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3968)
3969{
3970 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 3970, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail138;
3971 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.cc", 3971, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail138;
3972 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail138;
3973 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2640, __FILE__"generic-match.cc", __LINE__3973);
3974 {
3975 tree _r;
3976 _r = captures[0];
3977 return _r;
3978 }
3979next_after_fail138:;
3980 return NULL_TREE(tree) nullptr;
3981}
3982
3983static tree
3984generic_simplify_18 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3985 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3986)
3987{
3988 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail139;
3989 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1417, __FILE__"generic-match.cc", __LINE__3989);
3990 {
3991 tree res_op0;
3992 {
3993 tree _o1[2], _r1;
3994 _o1[0] = captures[1];
3995 _o1[1] = captures[2];
3996 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 3996, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3997 res_op0 = _r1;
3998 }
3999 tree _r;
4000 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4001 return _r;
4002 }
4003next_after_fail139:;
4004 return NULL_TREE(tree) nullptr;
4005}
4006
4007static tree
4008generic_simplify_19 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4009 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
4010, const combined_fn ARG_UNUSED (cond_op)cond_op __attribute__ ((__unused__)))
4011{
4012 {
4013/* #line 7942 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4014 tree op_type = TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc"
, 4014, __FUNCTION__))->typed.type)
;
4015/* #line 7943 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4016 if (element_precision (type) == element_precision (op_type)
4017)
4018 {
4019 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail140;
4020 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 7944, __FILE__"generic-match.cc", __LINE__4020);
4021 {
4022 tree res_op0;
4023 {
4024 tree _o1[4], _r1;
4025 _o1[0] = captures[0];
4026 _o1[1] = captures[1];
4027 _o1[2] = captures[2];
4028 {
4029 tree _o2[1], _r2;
4030 _o2[0] = captures[4];
4031 _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, op_type, _o2[0]);
4032 _o1[3] = _r2;
4033 }
4034 _r1 = maybe_build_call_expr_loc (loc, cond_op, TREE_TYPE (_o1[1])((contains_struct_check ((_o1[1]), (TS_TYPED), "generic-match.cc"
, 4034, __FUNCTION__))->typed.type)
, 4, _o1[0], _o1[1], _o1[2], _o1[3]);
4035 if (!_r1)
4036 goto next_after_fail140;
4037 res_op0 = _r1;
4038 }
4039 tree _r;
4040 _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
4041 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.cc", 4041, __FUNCTION__
))->base.side_effects_flag)
)
4042 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
4043 return _r;
4044 }
4045next_after_fail140:;
4046 }
4047 }
4048 return NULL_TREE(tree) nullptr;
4049}
4050
4051static tree
4052generic_simplify_20 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4053 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4054)
4055{
4056 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail141;
4057 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1422, __FILE__"generic-match.cc", __LINE__4057);
4058 {
4059 tree res_op0;
4060 res_op0 = captures[1];
4061 tree res_op1;
4062 {
4063 tree _o1[1], _r1;
4064 _o1[0] = captures[2];
4065 _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4065, __FUNCTION__))->typed.type)
, _o1[0]);
4066 res_op1 = _r1;
4067 }
4068 tree _r;
4069 _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
4070 return _r;
4071 }
4072next_after_fail141:;
4073 return NULL_TREE(tree) nullptr;
4074}
4075
4076static tree
4077generic_simplify_21 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4078 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4079, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4080{
4081/* #line 2340 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4082 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 4082, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 4082, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[2]
), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[2]), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 4082, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
4083 && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 4083, __FUNCTION__))->typed
.type))->base.code) == POINTER_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 4083, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 4083, __FUNCTION__))->typed.type)), "generic-match.cc", 4083
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
4084 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.cc", 4084, __FUNCTION__))->typed
.type))->base.code) == POINTER_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 4084, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 4084, __FUNCTION__))->typed.type)), "generic-match.cc", 4084
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
)
4085 && (CONSTANT_CLASS_P (captures[2])(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (captures[2])->base.code))] == tcc_constant)
|| (single_use (captures[1]) && single_use (captures[0])))
4086 && tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4086, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4086, __FUNCTION__))->typed.type)
)
4087 && tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4087, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc"
, 4087, __FUNCTION__))->typed.type)
)
4088)
4089 {
4090 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail142;
4091 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2346, __FILE__"generic-match.cc", __LINE__4091);
4092 {
4093 tree res_op0;
4094 res_op0 = captures[2];
4095 tree res_op1;
4096 res_op1 = build_zero_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 4096, __FUNCTION__))->typed.type)
);
4097 tree _r;
4098 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4099 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.cc", 4099, __FUNCTION__
))->base.side_effects_flag)
)
4100 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
4101 return _r;
4102 }
4103next_after_fail142:;
4104 }
4105 return NULL_TREE(tree) nullptr;
4106}
4107
4108static tree
4109generic_simplify_22 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4110 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4111)
4112{
4113 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail143;
4114 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1427, __FILE__"generic-match.cc", __LINE__4114);
4115 {
4116 tree res_op0;
4117 {
4118 tree _o1[2], _r1;
4119 _o1[0] = captures[1];
4120 _o1[1] = captures[2];
4121 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4121, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4122 res_op0 = _r1;
4123 }
4124 tree _r;
4125 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4126 return _r;
4127 }
4128next_after_fail143:;
4129 return NULL_TREE(tree) nullptr;
4130}
4131
4132static tree
4133generic_simplify_23 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4134 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4135)
4136{
4137/* #line 779 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4138 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
|| VECTOR_INTEGER_TYPE_P (type)((((enum tree_code) (type)->base.code) == VECTOR_TYPE) &&
((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.cc", 4138, __FUNCTION__))->typed.type))->
base.code) == INTEGER_TYPE)
4139)
4140 {
4141 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail144;
4142 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 780, __FILE__"generic-match.cc", __LINE__4142);
4143 {
4144 tree res_op0;
4145 {
4146 tree _o1[2], _r1;
4147 _o1[0] = captures[0];
4148 _o1[1] = captures[1];
4149 _r1 = fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4149, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4150 res_op0 = _r1;
4151 }
4152 tree _r;
4153 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4154 return _r;
4155 }
4156next_after_fail144:;
4157 }
4158 return NULL_TREE(tree) nullptr;
4159}
4160
4161static tree
4162generic_simplify_24 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4163 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4164, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4165{
4166/* #line 2372 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4167 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4167, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4167, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 4167, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
4168 && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4168, __FUNCTION__))->typed
.type))->base.code) == POINTER_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4168, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4168, __FUNCTION__))->typed.type)), "generic-match.cc", 4168
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
4169 || ((op == EQ_EXPR || op == NE_EXPR)
4170 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4170, __FUNCTION__))->typed
.type))->base.code) == POINTER_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4170, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4170, __FUNCTION__))->typed.type)), "generic-match.cc", 4170
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
))
4171 && (CONSTANT_CLASS_P (captures[2])(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (captures[2])->base.code))] == tcc_constant)
|| single_use (captures[1]))
4172)
4173 {
4174 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail145;
4175 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2377, __FILE__"generic-match.cc", __LINE__4175);
4176 {
4177 tree res_op0;
4178 res_op0 = captures[2];
4179 tree res_op1;
4180 res_op1 = build_zero_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.cc"
, 4180, __FUNCTION__))->typed.type)
);
4181 tree _r;
4182 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4183 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4183, __FUNCTION__
))->base.side_effects_flag)
)
4184 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4185 return _r;
4186 }
4187next_after_fail145:;
4188 }
4189 return NULL_TREE(tree) nullptr;
4190}
4191
4192static tree
4193generic_simplify_25 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4194 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4195, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (rbitop)rbitop __attribute__ ((__unused__)))
4196{
4197 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.cc", 4197, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail146;
4198 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail146;
4199 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1435, __FILE__"generic-match.cc", __LINE__4199);
4200 {
4201 tree res_op0;
4202 res_op0 = captures[1];
4203 tree res_op1;
4204 res_op1 = captures[2];
4205 tree _r;
4206 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
4207 return _r;
4208 }
4209next_after_fail146:;
4210 return NULL_TREE(tree) nullptr;
4211}
4212
4213static tree
4214generic_simplify_26 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4215 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4216, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4217{
4218/* #line 2258 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4219 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4219, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4219, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4219, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4220 && TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4220, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4220, __FUNCTION__))
->base.u.bits.unsigned_flag)
4221 && wi::only_sign_bit_p (wi::to_wide (captures[1]))
4222)
4223 {
4224 {
4225/* #line 2261 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4226 tree stype = signed_type_for (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4226, __FUNCTION__))->typed.type)
);
4227 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail147;
4228 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2262, __FILE__"generic-match.cc", __LINE__4228);
4229 {
4230 tree res_op0;
4231 {
4232 tree _o1[1], _r1;
4233 _o1[0] = captures[0];
4234 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4234, __FUNCTION__))->typed.type)
!= stype)
4235 _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
4236 else
4237 _r1 = _o1[0];
4238 res_op0 = _r1;
4239 }
4240 tree res_op1;
4241 {
4242 tree _o1[1], _r1;
4243 _o1[0] = captures[2];
4244 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4244, __FUNCTION__))->typed.type)
!= stype)
4245 _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
4246 else
4247 _r1 = _o1[0];
4248 res_op1 = _r1;
4249 }
4250 tree _r;
4251 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4252 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4252, __FUNCTION__
))->base.side_effects_flag)
)
4253 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4254 return _r;
4255 }
4256next_after_fail147:;
4257 }
4258 }
4259 return NULL_TREE(tree) nullptr;
4260}
4261
4262static tree
4263generic_simplify_27 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4264 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4265)
4266{
4267 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail148;
4268 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1440, __FILE__"generic-match.cc", __LINE__4268);
4269 {
4270 tree res_op0;
4271 res_op0 = captures[0];
4272 tree res_op1;
4273 res_op1 = captures[1];
4274 tree _r;
4275 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
4276 return _r;
4277 }
4278next_after_fail148:;
4279 return NULL_TREE(tree) nullptr;
4280}
4281
4282static tree
4283generic_simplify_28 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4284 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4285, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (icmp)icmp __attribute__ ((__unused__)))
4286{
4287/* #line 5522 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4288 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4288, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE)
4289 && ! DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4289, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE) && (((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4289, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.cc", 4289, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4289, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4289, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
4290)
4291 {
4292 {
4293/* #line 5524 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4294 tree itype = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4294, __FUNCTION__))->typed.type)
;
4295 format_helper fmt (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (captures[1])))(real_format_for_mode[(((enum mode_class) mode_class[((((enum
tree_code) ((tree_class_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.cc", 4295, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT) ? ((((
(((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.cc", 4295, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed
.type))->type_common.mode)) - MIN_MODE_DECIMAL_FLOAT) + (MAX_MODE_FLOAT
- MIN_MODE_FLOAT + 1)) : ((enum mode_class) mode_class[((((enum
tree_code) ((tree_class_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.cc", 4295, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_FLOAT ? ((((((enum tree_code
) ((tree_class_check ((((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4295, __FUNCTION__))
)->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4295, __FUNCTION__))->typed
.type))->type_common.mode)) - MIN_MODE_FLOAT) : ((fancy_abort
("generic-match.cc", 4295, __FUNCTION__)), 0)])
);
4296 const REAL_VALUE_TYPEstruct real_value *cst = TREE_REAL_CST_PTR (captures[1])(&(tree_check ((captures[1]), "generic-match.cc", 4296, __FUNCTION__
, (REAL_CST)))->real_cst.value)
;
4297 bool exception_p
4298 = real_isnan (cst) && (cst->signalling
4299 || (cmp != EQ_EXPR && cmp != NE_EXPR));
4300/* #line 5539 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4301 if (fmt.can_represent_integral_type_p (itype) && ! exception_p
4302)
4303 {
4304 {
4305/* #line 5540 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4306 signop isign = TYPE_SIGN (itype)((signop) ((tree_class_check ((itype), (tcc_type), "generic-match.cc"
, 4306, __FUNCTION__))->base.u.bits.unsigned_flag))
;
4307 REAL_VALUE_TYPEstruct real_value imin, imax;
4308 real_from_integer (&imin, fmt, wi::min_value (itype), isign);
4309 real_from_integer (&imax, fmt, wi::max_value (itype), isign);
4310 REAL_VALUE_TYPEstruct real_value icst;
4311 if (cmp == GT_EXPR || cmp == GE_EXPR)
4312 real_ceil (&icst, fmt, cst);
4313 else if (cmp == LT_EXPR || cmp == LE_EXPR)
4314 real_floor (&icst, fmt, cst);
4315 else
4316 real_trunc (&icst, fmt, cst);
4317 bool cst_int_p = !real_isnan (cst) && real_identical (&icst, cst);
4318 bool overflow_p = false;
4319 wide_int icst_val
4320 = real_to_integer (&icst, &overflow_p, TYPE_PRECISION (itype)((tree_class_check ((itype), (tcc_type), "generic-match.cc", 4320
, __FUNCTION__))->type_common.precision)
);
4321/* #line 5563 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4322 if (real_compare (LT_EXPR, cst, &imin)
4323)
4324 {
4325 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4325, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail149;
4326 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail149;
4327 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5564, __FILE__"generic-match.cc", __LINE__4327);
4328 {
4329 tree _r;
4330 _r = constant_boolean_node (cmp == GT_EXPR || cmp == GE_EXPR || cmp == NE_EXPR,
4331 type);
4332 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4332, __FUNCTION__
))->base.side_effects_flag)
)
4333 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4334 return _r;
4335 }
4336next_after_fail149:;
4337 }
4338 else
4339 {
4340/* #line 5566 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4341 if (real_compare (GT_EXPR, cst, &imax)
4342)
4343 {
4344 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4344, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail150;
4345 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail150;
4346 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5567, __FILE__"generic-match.cc", __LINE__4346);
4347 {
4348 tree _r;
4349 _r = constant_boolean_node (cmp == LT_EXPR || cmp == LE_EXPR || cmp == NE_EXPR,
4350 type);
4351 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4351, __FUNCTION__
))->base.side_effects_flag)
)
4352 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4353 return _r;
4354 }
4355next_after_fail150:;
4356 }
4357 else
4358 {
4359/* #line 5570 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4360 if (cst_int_p
4361)
4362 {
4363 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4363, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail151;
4364 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail151;
4365 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5571, __FILE__"generic-match.cc", __LINE__4365);
4366 {
4367 tree res_op0;
4368 res_op0 = captures[0];
4369 tree res_op1;
4370 gcc_assert (!overflow_p)((void)(!(!overflow_p) ? fancy_abort ("generic-match.cc", 4370
, __FUNCTION__), 0 : 0))
; res_op1 =
4371 wide_int_to_tree (itype, icst_val);
4372 tree _r;
4373 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4374 return _r;
4375 }
4376next_after_fail151:;
4377 }
4378 else
4379 {
4380/* #line 5577 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4381 if (cmp == EQ_EXPR || cmp == NE_EXPR
4382)
4383 {
4384 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4384, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail152;
4385 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail152;
4386 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5578, __FILE__"generic-match.cc", __LINE__4386);
4387 {
4388 tree _r;
4389 _r = constant_boolean_node (cmp == NE_EXPR, type);
4390 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4390, __FUNCTION__
))->base.side_effects_flag)
)
4391 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4392 return _r;
4393 }
4394next_after_fail152:;
4395 }
4396 else
4397 {
4398 {
4399/* #line 5580 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4400 gcc_checking_assert (!overflow_p)((void)(!(!overflow_p) ? fancy_abort ("generic-match.cc", 4400
, __FUNCTION__), 0 : 0))
;
4401 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4401, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail153;
4402 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail153;
4403 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5584, __FILE__"generic-match.cc", __LINE__4403);
4404 {
4405 tree res_op0;
4406 res_op0 = captures[0];
4407 tree res_op1;
4408 res_op1 = wide_int_to_tree (itype, icst_val);
4409 tree _r;
4410 _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
4411 return _r;
4412 }
4413next_after_fail153:;
4414 }
4415 }
4416 }
4417 }
4418 }
4419 }
4420 }
4421 }
4422 }
4423 return NULL_TREE(tree) nullptr;
4424}
4425
4426static tree
4427generic_simplify_29 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4428 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4429, const combined_fn ARG_UNUSED (POW)POW __attribute__ ((__unused__)))
4430{
4431 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail154;
4432 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6705, __FILE__"generic-match.cc", __LINE__4432);
4433 {
4434 tree _r;
4435 _r = captures[0];
4436 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4436, __FUNCTION__
))->base.side_effects_flag)
)
4437 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4438 return _r;
4439 }
4440next_after_fail154:;
4441 return NULL_TREE(tree) nullptr;
4442}
4443
4444static tree
4445generic_simplify_30 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4446 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4447, const enum tree_code ARG_UNUSED (minmax)minmax __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (out)out __attribute__ ((__unused__)))
4448{
4449/* #line 3535 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4450 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4450, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4450, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 4450, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
4451)
4452 {
4453 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail155;
4454 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3536, __FILE__"generic-match.cc", __LINE__4454);
4455 {
4456 tree res_op0;
4457 res_op0 = captures[0];
4458 tree res_op1;
4459 res_op1 = captures[1];
4460 tree _r;
4461 _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
4462 return _r;
4463 }
4464next_after_fail155:;
4465 }
4466 return NULL_TREE(tree) nullptr;
4467}
4468
4469static tree
4470generic_simplify_31 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4471 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4472, const enum tree_code ARG_UNUSED (eqne)eqne __attribute__ ((__unused__)))
4473{
4474/* #line 2599 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4475 if (eqne == EQ_EXPR
4476)
4477 {
4478 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 4478, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail156;
4479 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail156;
4480 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2600, __FILE__"generic-match.cc", __LINE__4480);
4481 {
4482 tree _r;
4483 _r = constant_boolean_node (false, type);
4484 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4484, __FUNCTION__
))->base.side_effects_flag)
)
4485 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4486 return _r;
4487 }
4488next_after_fail156:;
4489 }
4490 else
4491 {
4492/* #line 2601 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4493 if (eqne == NE_EXPR
4494)
4495 {
4496 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.cc", 4496, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail157;
4497 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.cc", 4497, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail157;
4498 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail157;
4499 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2602, __FILE__"generic-match.cc", __LINE__4499);
4500 {
4501 tree _r;
4502 _r = captures[0];
4503 return _r;
4504 }
4505next_after_fail157:;
4506 }
4507 }
4508 return NULL_TREE(tree) nullptr;
4509}
4510
4511static tree
4512generic_simplify_32 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4513 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4514, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4515{
4516/* #line 5737 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4517 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4517, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4517, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 4517, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4518 && !(targetm.have_canonicalize_funcptr_for_compare ()
4519 && ((POINTER_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4519, __FUNCTION__))->typed
.type))->base.code) == POINTER_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4519, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
4520 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[1])))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4520, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.cc", 4520, __FUNCTION__
))->typed.type))->base.code) == FUNCTION_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4520, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.cc", 4520, __FUNCTION__
))->typed.type))->base.code) == METHOD_TYPE)
)
4521 || (POINTER_TYPE_P (TREE_TYPE (captures[3]))(((enum tree_code) (((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.cc", 4521, __FUNCTION__))->typed
.type))->base.code) == POINTER_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc"
, 4521, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
4522 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[3])))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
((captures[3]), (TS_TYPED), "generic-match.cc", 4522, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.cc", 4522, __FUNCTION__
))->typed.type))->base.code) == FUNCTION_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[3]), (TS_TYPED), "generic-match.cc", 4522, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.cc", 4522, __FUNCTION__
))->typed.type))->base.code) == METHOD_TYPE)
)))
4523 && single_use (captures[0])
4524)
4525 {
4526/* #line 5746 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4527 if (TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4527, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4527, __FUNCTION__))
->type_common.precision)
== TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4527, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4527, __FUNCTION__))
->type_common.precision)
4528 && (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4529 || captures[2] != captures[3])
4530 && (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4530, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4530, __FUNCTION__))
->base.u.bits.unsigned_flag)
== TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4530, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4530, __FUNCTION__))
->base.u.bits.unsigned_flag)
4531 || cmp == NE_EXPR
4532 || cmp == EQ_EXPR)
4533 && !POINTER_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4533, __FUNCTION__))->typed
.type))->base.code) == POINTER_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4533, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
4534 && (TREE_CODE (TREE_TYPE (captures[1]))((enum tree_code) (((contains_struct_check ((captures[1]), (TS_TYPED
), "generic-match.cc", 4534, __FUNCTION__))->typed.type))->
base.code)
!= BOOLEAN_TYPE
4535 || TREE_CODE (TREE_TYPE (captures[3]))((enum tree_code) (((contains_struct_check ((captures[3]), (TS_TYPED
), "generic-match.cc", 4535, __FUNCTION__))->typed.type))->
base.code)
== BOOLEAN_TYPE)
4536)
4537 {
4538/* #line 5761 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4539 if (TREE_CODE (captures[2])((enum tree_code) (captures[2])->base.code) == INTEGER_CST
4540)
4541 {
4542 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4542, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail158;
4543 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail158;
4544 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5762, __FILE__"generic-match.cc", __LINE__4544);
4545 {
4546 tree res_op0;
4547 res_op0 = captures[1];
4548 tree res_op1;
4549 res_op1 = force_fit_type (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4549, __FUNCTION__))->typed.type)
, wi::to_widest (captures[2]), 0,
4550 TREE_OVERFLOW (captures[2])((tree_class_check ((captures[2]), (tcc_constant), "generic-match.cc"
, 4550, __FUNCTION__))->base.public_flag)
);
4551 tree _r;
4552 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4553 return _r;
4554 }
4555next_after_fail158:;
4556 }
4557 else
4558 {
4559 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail159;
4560 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5764, __FILE__"generic-match.cc", __LINE__4560);
4561 {
4562 tree res_op0;
4563 res_op0 = captures[1];
4564 tree res_op1;
4565 {
4566 tree _o1[1], _r1;
4567 _o1[0] = captures[2];
4568 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4568, __FUNCTION__))->typed.type)
!= TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.cc"
, 4568, __FUNCTION__))->typed.type)
)
4569 _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.cc"
, 4569, __FUNCTION__))->typed.type)
, _o1[0]);
4570 else
4571 _r1 = _o1[0];
4572 res_op1 = _r1;
4573 }
4574 tree _r;
4575 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4576 return _r;
4577 }
4578next_after_fail159:;
4579 }
4580 }
4581 else
4582 {
4583/* #line 5766 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4584 if (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4584, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4584, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4584, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4584, __FUNCTION__))
->type_common.precision)
4585)
4586 {
4587/* #line 5768 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4588 if ((cmp == EQ_EXPR || cmp == NE_EXPR
4589 || TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4589, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4589, __FUNCTION__))
->base.u.bits.unsigned_flag)
== TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4589, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4589, __FUNCTION__))
->base.u.bits.unsigned_flag)
4590 || (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4590, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4590, __FUNCTION__))
->base.u.bits.unsigned_flag)
4591 && TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4591, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4591, __FUNCTION__))
->base.u.bits.unsigned_flag)
))
4592 && (types_match (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc"
, 4592, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4592, __FUNCTION__))->typed.type)
)
4593 || ((TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4593, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4593, __FUNCTION__))
->type_common.precision)
4594 >= TYPE_PRECISION (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.cc", 4594, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4594, __FUNCTION__))
->type_common.precision)
)
4595 && (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4595, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4595, __FUNCTION__))
->base.u.bits.unsigned_flag)
4596 == TYPE_UNSIGNED (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.cc", 4596, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4596, __FUNCTION__))
->base.u.bits.unsigned_flag)
))
4597 || (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4598 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4598, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4598, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4598, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4599 && int_fits_type_p (captures[3], TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4599, __FUNCTION__))->typed.type)
)))
4600)
4601 {
4602 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail160;
4603 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5780, __FILE__"generic-match.cc", __LINE__4603);
4604 {
4605 tree res_op0;
4606 res_op0 = captures[1];
4607 tree res_op1;
4608 {
4609 tree _o1[1], _r1;
4610 _o1[0] = captures[3];
4611 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4611, __FUNCTION__))->typed.type)
!= TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.cc"
, 4611, __FUNCTION__))->typed.type)
)
4612 _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.cc"
, 4612, __FUNCTION__))->typed.type)
, _o1[0]);
4613 else
4614 _r1 = _o1[0];
4615 res_op1 = _r1;
4616 }
4617 tree _r;
4618 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4619 return _r;
4620 }
4621next_after_fail160:;
4622 }
4623 else
4624 {
4625/* #line 5781 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4626 if (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4627 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4627, __FUNCTION__))->typed
.type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4627, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4627, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4628 && !int_fits_type_p (captures[3], TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4628, __FUNCTION__))->typed.type)
)
4629)
4630 {
4631 {
4632/* #line 5784 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4633 tree min = lower_bound_in_type (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc"
, 4633, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4633, __FUNCTION__))->typed.type)
);
4634 tree max = upper_bound_in_type (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc"
, 4634, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4634, __FUNCTION__))->typed.type)
);
4635 bool above = integer_nonzerop (const_binop (LT_EXPR, type, max, captures[3]));
4636 bool below = integer_nonzerop (const_binop (LT_EXPR, type, captures[3], min));
4637/* #line 5791 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4638 if (above || below
4639)
4640 {
4641/* #line 5792 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4642 if (cmp == EQ_EXPR || cmp == NE_EXPR
4643)
4644 {
4645 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail161;
4646 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5793, __FILE__"generic-match.cc", __LINE__4646);
4647 {
4648 tree _r;
4649 _r = constant_boolean_node (cmp == EQ_EXPR ? false : true, type);
4650 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4650, __FUNCTION__
))->base.side_effects_flag)
)
4651 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4652 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4652, __FUNCTION__
))->base.side_effects_flag)
)
4653 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4654 return _r;
4655 }
4656next_after_fail161:;
4657 }
4658 else
4659 {
4660/* #line 5794 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4661 if (cmp == LT_EXPR || cmp == LE_EXPR
4662)
4663 {
4664 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail162;
4665 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5795, __FILE__"generic-match.cc", __LINE__4665);
4666 {
4667 tree _r;
4668 _r = constant_boolean_node (above ? true : false, type);
4669 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4669, __FUNCTION__
))->base.side_effects_flag)
)
4670 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4671 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4671, __FUNCTION__
))->base.side_effects_flag)
)
4672 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4673 return _r;
4674 }
4675next_after_fail162:;
4676 }
4677 else
4678 {
4679/* #line 5796 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4680 if (cmp == GT_EXPR || cmp == GE_EXPR
4681)
4682 {
4683 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail163;
4684 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5797, __FILE__"generic-match.cc", __LINE__4684);
4685 {
4686 tree _r;
4687 _r = constant_boolean_node (above ? false : true, type);
4688 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4688, __FUNCTION__
))->base.side_effects_flag)
)
4689 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4690 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4690, __FUNCTION__
))->base.side_effects_flag)
)
4691 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4692 return _r;
4693 }
4694next_after_fail163:;
4695 }
4696 }
4697 }
4698 }
4699 }
4700 }
4701 }
4702 }
4703 }
4704 }
4705 else
4706 {
4707/* #line 5799 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4708 if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4708, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE) || ((((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4708, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[1]
), (TS_TYPED), "generic-match.cc", 4708, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.cc", 4708, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.cc", 4708, __FUNCTION__
))->typed.type))->base.code) == REAL_TYPE)))
4709 && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4709, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE) && (((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.cc", 4709, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.cc", 4709, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.cc", 4709, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 4709, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
4710 == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4710, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE) && (((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4710, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.cc", 4710, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.cc", 4710, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.cc", 4710, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
)
4711 && (DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4711, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE) && (((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.cc", 4711, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.cc", 4711, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.cc", 4711, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.cc", 4711, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
4712 == DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[3]))((((enum tree_code) (((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.cc", 4712, __FUNCTION__))->typed
.type))->base.code) == REAL_TYPE) && (((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[3]), (TS_TYPED), "generic-match.cc", 4712, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.cc", 4712, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[3]), (TS_TYPED), "generic-match.cc", 4712, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[3])
, (TS_TYPED), "generic-match.cc", 4712, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
)
4713)
4714 {
4715 {
4716/* #line 5804 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4717 tree type1 = TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.cc"
, 4717, __FUNCTION__))->typed.type)
;
4718 if (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (type1)((((enum tree_code) (type1)->base.code) == REAL_TYPE) &&
(((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((type1), (tcc_type), "generic-match.cc", 4718, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (type1)
: (type1)->type_common.mode)]) == MODE_DECIMAL_FLOAT))
)
4719 {
4720 REAL_VALUE_TYPEstruct real_value orig = TREE_REAL_CST (captures[3])(*(&(tree_check ((captures[3]), "generic-match.cc", 4720,
__FUNCTION__, (REAL_CST)))->real_cst.value))
;
4721 if (TYPE_PRECISION (type1)((tree_class_check ((type1), (tcc_type), "generic-match.cc", 4721
, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (float_type_node)((tree_class_check ((global_trees[TI_FLOAT_TYPE]), (tcc_type)
, "generic-match.cc", 4721, __FUNCTION__))->type_common.precision
)
4722 && exact_real_truncate (TYPE_MODE (float_type_node)((((enum tree_code) ((tree_class_check ((global_trees[TI_FLOAT_TYPE
]), (tcc_type), "generic-match.cc", 4722, __FUNCTION__)))->
base.code) == VECTOR_TYPE) ? vector_type_mode (global_trees[TI_FLOAT_TYPE
]) : (global_trees[TI_FLOAT_TYPE])->type_common.mode)
, &orig))
4723 type1 = float_type_nodeglobal_trees[TI_FLOAT_TYPE];
4724 if (TYPE_PRECISION (type1)((tree_class_check ((type1), (tcc_type), "generic-match.cc", 4724
, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (double_type_node)((tree_class_check ((global_trees[TI_DOUBLE_TYPE]), (tcc_type
), "generic-match.cc", 4724, __FUNCTION__))->type_common.precision
)
4725 && exact_real_truncate (TYPE_MODE (double_type_node)((((enum tree_code) ((tree_class_check ((global_trees[TI_DOUBLE_TYPE
]), (tcc_type), "generic-match.cc", 4725, __FUNCTION__)))->
base.code) == VECTOR_TYPE) ? vector_type_mode (global_trees[TI_DOUBLE_TYPE
]) : (global_trees[TI_DOUBLE_TYPE])->type_common.mode)
, &orig))
4726 type1 = double_type_nodeglobal_trees[TI_DOUBLE_TYPE];
4727 }
4728 tree newtype
4729 = (TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.cc", 4729, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4729, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (type1)((tree_class_check ((type1), (tcc_type), "generic-match.cc", 4729
, __FUNCTION__))->type_common.precision)
4730 ? TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 4730, __FUNCTION__))->typed.type)
: type1);
4731/* #line 5821 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4732 if (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.cc", 4732, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.cc", 4732, __FUNCTION__))
->type_common.precision)
> TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.cc"
, 4732, __FUNCTION__))->type_common.precision)
4733)
4734 {
4735 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail164;
4736 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5822, __FILE__"generic-match.cc", __LINE__4736);
4737 {
4738 tree res_op0;
4739 {
4740 tree _o1[1], _r1;
4741 _o1[0] = captures[1];
4742 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4742, __FUNCTION__))->typed.type)
!= newtype)
4743 _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
4744 else
4745 _r1 = _o1[0];
4746 res_op0 = _r1;
4747 }
4748 tree res_op1;
4749 {
4750 tree _o1[1], _r1;
4751 _o1[0] = captures[3];
4752 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 4752, __FUNCTION__))->typed.type)
!= newtype)
4753 _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
4754 else
4755 _r1 = _o1[0];
4756 res_op1 = _r1;
4757 }
4758 tree _r;
4759 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4760 return _r;
4761 }
4762next_after_fail164:;
4763 }
4764 }
4765 }
4766 }
4767 return NULL_TREE(tree) nullptr;
4768}
4769
4770static tree
4771generic_simplify_33 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4772 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4773, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4774{
4775 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail165;
4776 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1453, __FILE__"generic-match.cc", __LINE__4776);
4777 {
4778 tree res_op0;
4779 res_op0 = captures[0];
4780 tree res_op1;
4781 res_op1 = captures[1];
4782 tree _r;
4783 _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
4784 return _r;
4785 }
4786next_after_fail165:;
4787 return NULL_TREE(tree) nullptr;
4788}
4789
4790static tree
4791generic_simplify_34 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4792 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4793, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4794{
4795/* #line 3551 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4796 if (wi::gt_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
4797 TYPE_SIGN (TREE_TYPE (captures[0]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.cc", 4797, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.cc", 4797, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
4798)
4799 {
4800 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail166;
4801 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3553, __FILE__"generic-match.cc", __LINE__4801);
4802 {
4803 tree _r;
4804 _r = constant_boolean_node (cmp == NE_EXPR, type);
4805 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4805, __FUNCTION__
))->base.side_effects_flag)
)
4806 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4807 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4807, __FUNCTION__
))->base.side_effects_flag)
)
4808 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4809 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4809, __FUNCTION__
))->base.side_effects_flag)
)
4810 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4811 return _r;
4812 }
4813next_after_fail166:;
4814 }
4815 else
4816 {
4817/* #line 3554 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4818 if (wi::lt_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
4819 TYPE_SIGN (TREE_TYPE (captures[0]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.cc", 4819, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.cc", 4819, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
4820)
4821 {
4822 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail167;
4823 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3556, __FILE__"generic-match.cc", __LINE__4823);
4824 {
4825 tree res_op0;
4826 res_op0 = captures[0];
4827 tree res_op1;
4828 res_op1 = captures[2];
4829 tree _r;
4830 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4831 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4831, __FUNCTION__
))->base.side_effects_flag)
)
4832 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4833 return _r;
4834 }
4835next_after_fail167:;
4836 }
4837 }
4838 return NULL_TREE(tree) nullptr;
4839}
4840
4841static tree
4842generic_simplify_35 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4843 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4844, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4845{
4846 {
4847/* #line 5829 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4848 poly_int64 off; tree base;
4849 tree addr = (TREE_CODE (captures[0])((enum tree_code) (captures[0])->base.code) == SSA_NAME
4850 ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])(tree_check ((captures[0]), "generic-match.cc", 4850, __FUNCTION__
, (SSA_NAME)))->ssa_name.def_stmt
) : captures[0]);
4851/* #line 5837 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4852 if (SSA_NAME_IS_DEFAULT_DEF (captures[1])(tree_check ((captures[1]), "generic-match.cc", 4852, __FUNCTION__
, (SSA_NAME)))->base.default_def_flag
4853 && TREE_CODE (SSA_NAME_VAR (captures[1]))((enum tree_code) (((tree_check ((captures[1]), "generic-match.cc"
, 4853, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((captures[1])->ssa_name.var
)->base.code) == IDENTIFIER_NODE ? (tree) nullptr : (captures
[1])->ssa_name.var))->base.code)
== PARM_DECL
4854 && (base = get_base_address (TREE_OPERAND (addr, 0)(*((const_cast<tree*> (tree_operand_check ((addr), (0),
"generic-match.cc", 4854, __FUNCTION__)))))
))
4855 && TREE_CODE (base)((enum tree_code) (base)->base.code) == VAR_DECL
4856 && auto_var_in_fn_p (base, current_function_decl)
4857)
4858 {
4859/* #line 5842 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4860 if (cmp == NE_EXPR
4861)
4862 {
4863 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4863, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail168;
4864 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail168;
4865 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5843, __FILE__"generic-match.cc", __LINE__4865);
4866 {
4867 tree _r;
4868 _r = constant_boolean_node (true, type);
4869 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4869, __FUNCTION__
))->base.side_effects_flag)
)
4870 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4871 return _r;
4872 }
4873next_after_fail168:;
4874 }
4875 else
4876 {
4877 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4877, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail169;
4878 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail169;
4879 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5844, __FILE__"generic-match.cc", __LINE__4879);
4880 {
4881 tree _r;
4882 _r = constant_boolean_node (false, type);
4883 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4883, __FUNCTION__
))->base.side_effects_flag)
)
4884 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4885 return _r;
4886 }
4887next_after_fail169:;
4888 }
4889 }
4890 else
4891 {
4892/* #line 5846 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4893 if ((base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0)(*((const_cast<tree*> (tree_operand_check ((addr), (0),
"generic-match.cc", 4893, __FUNCTION__)))))
, &off))
4894 && TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF
4895 && TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
"generic-match.cc", 4895, __FUNCTION__)))))
== captures[1]
4896)
4897 {
4898 {
4899/* #line 5849 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4900 off += mem_ref_offset (base).force_shwi ();
4901/* #line 5850 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4902 if (known_ne (off, 0)(!maybe_eq (off, 0))
4903)
4904 {
4905 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4905, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail170;
4906 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail170;
4907 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5851, __FILE__"generic-match.cc", __LINE__4907);
4908 {
4909 tree _r;
4910 _r = constant_boolean_node (cmp == NE_EXPR, type);
4911 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4911, __FUNCTION__
))->base.side_effects_flag)
)
4912 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4913 return _r;
4914 }
4915next_after_fail170:;
4916 }
4917 else
4918 {
4919/* #line 5852 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4920 if (known_eq (off, 0)(!maybe_ne (off, 0))
4921)
4922 {
4923 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4923, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail171;
4924 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail171;
4925 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5853, __FILE__"generic-match.cc", __LINE__4925);
4926 {
4927 tree _r;
4928 _r = constant_boolean_node (cmp == EQ_EXPR, type);
4929 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4929, __FUNCTION__
))->base.side_effects_flag)
)
4930 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4931 return _r;
4932 }
4933next_after_fail171:;
4934 }
4935 }
4936 }
4937 }
4938 }
4939 }
4940 return NULL_TREE(tree) nullptr;
4941}
4942
4943static tree
4944generic_simplify_36 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4945 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4946, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4947{
4948/* #line 5606 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4949 if (wi::gt_p (wi::to_wide (captures[1]), 0, TYPE_SIGN (TREE_TYPE (captures[1]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.cc", 4949, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.cc", 4949, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
4950)
4951 {
4952 {
4953/* #line 5607 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4954 wi::overflow_type ovf;
4955 wide_int prod = wi::mul (wi::to_wide (captures[2]), wi::to_wide (captures[1]),
4956 TYPE_SIGN (TREE_TYPE (captures[1]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.cc", 4956, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.cc", 4956, __FUNCTION__
))->base.u.bits.unsigned_flag))
, &ovf);
4957/* #line 5613 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4958 if (ovf
4959)
4960 {
4961 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4961, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail172;
4962 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4962, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail172;
4963 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail172;
4964 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5614, __FILE__"generic-match.cc", __LINE__4964);
4965 {
4966 tree _r;
4967 _r = constant_boolean_node (wi::lt_p (wi::to_wide (captures[2]), 0,
4968 TYPE_SIGN (TREE_TYPE (captures[2]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.cc", 4968, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.cc", 4968, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
4969 != (cmp == LT_EXPR || cmp == LE_EXPR), type);
4970 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 4970, __FUNCTION__
))->base.side_effects_flag)
)
4971 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4972 return _r;
4973 }
4974next_after_fail172:;
4975 }
4976 else
4977 {
4978 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.cc", 4978, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail173;
4979 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.cc", 4979, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail173;
4980 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail173;
4981 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5617, __FILE__"generic-match.cc", __LINE__4981);
4982 {
4983 tree res_op0;
4984 res_op0 = captures[0];
4985 tree res_op1;
4986 res_op1 = wide_int_to_tree (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 4986, __FUNCTION__))->typed.type)
, prod);
4987 tree _r;
4988 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4989 return _r;
4990 }
4991next_after_fail173:;
4992 }
4993 }
4994 }
4995 return NULL_TREE(tree) nullptr;
4996}
4997
4998static tree
4999generic_simplify_37 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5000 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5001)
5002{
5003/* #line 2805 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5004 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.cc", 5004, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
5005)
5006 {
5007/* #line 2863 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5008 if ((!FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.cc", 5008, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
|| flag_associative_mathglobal_options.x_flag_associative_math)
5009 && !FIXED_POINT_TYPE_P (type)(((enum tree_code) (type)->base.code) == FIXED_POINT_TYPE)
5010)
5011 {
5012 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail174;
5013 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2909, __FILE__"generic-match.cc", __LINE__5013);
5014 {
5015 tree res_op0;
5016 res_op0 = captures[1];
5017 tree res_op1;
5018 res_op1 = captures[2];
5019 tree _r;
5020 _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
5021 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.cc", 5021, __FUNCTION__
))->base.side_effects_flag)
)
5022 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5023 return _r;
5024 }
5025next_after_fail174:;
5026 }
5027 }
5028 return NULL_TREE(tree) nullptr;
5029}
5030
5031static tree
5032generic_simplify_38 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5033 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5034, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (rop)rop __attribute__ ((__unused__)))
5035{
5036/* #line 1544 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5037 if (element_precision (type) <= element_precision (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.cc"
, 5037, __FUNCTION__))->typed.type)
)
5038 && element_precision (type) <= element_precision (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.cc"
, 5038, __FUNCTION__))->typed.type)
)
5039)
5040 {
5041 if (UNLIKELY (!dbg_cnt (match))(__builtin_expect ((!dbg_cnt (match)), 0))) goto next_after_fail175;
5042 if (UNLIKELY (dump_file && (dump_flags & TDF_FOLDING))(__builtin_expect ((dump_file && (dump_flags & TDF_FOLDING
)), 0))
) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1546, __FILE__"generic-match.cc", __LINE__5042);
5043 {
5044 tree res_op0;
5045 {
5046 tree _o1[2], _r1;
5047 {
5048 tree _o2[1], _r2;
5049 _o2[0] = captures[0];
5050 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc"
, 5050, __FUNCTION__))->typed.type)
!= type)
5051 _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
5052 else
5053 _r2 = _o2[0];
5054 _o1[0] = _r2;
5055 }
5056 {
5057 tree _o2[1], _r2;
5058 _o2[0] = captures[1];
5059 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.cc"
, 5059, __FUNCTION__))->typed.type)
!= type)
5060 _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
5061 else
5062 _r2 = _o2[0];
5063 _o1[1] = _r2;
5064 }
5065 _r1 = fold_build2_loc (loc, rop, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.cc"
, 5065, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
5066 res_op0 = _r1;
5067 }