Mercurial > hg > CbC > CbC_gcc
comparison gcc/gimple-match.h @ 131:84e7813d76e9
gcc-8.2
author | mir3636 |
---|---|
date | Thu, 25 Oct 2018 07:37:49 +0900 |
parents | 04ced10e8804 |
children | 1830386684a0 |
comparison
equal
deleted
inserted
replaced
111:04ced10e8804 | 131:84e7813d76e9 |
---|---|
1 /* Gimple simplify definitions. | 1 /* Gimple simplify definitions. |
2 | 2 |
3 Copyright (C) 2011-2017 Free Software Foundation, Inc. | 3 Copyright (C) 2011-2018 Free Software Foundation, Inc. |
4 Contributed by Richard Guenther <rguenther@suse.de> | 4 Contributed by Richard Guenther <rguenther@suse.de> |
5 | 5 |
6 This file is part of GCC. | 6 This file is part of GCC. |
7 | 7 |
8 GCC is free software; you can redistribute it and/or modify it under | 8 GCC is free software; you can redistribute it and/or modify it under |
38 int get_rep () const { return rep; } | 38 int get_rep () const { return rep; } |
39 private: | 39 private: |
40 int rep; | 40 int rep; |
41 }; | 41 }; |
42 | 42 |
43 /* Return whether OPS[0] with CODE is a non-expression result and | 43 /* Represents the condition under which an operation should happen, |
44 a gimple value. */ | 44 and the value to use otherwise. The condition applies elementwise |
45 (as for VEC_COND_EXPR) if the values are vectors. */ | |
46 struct gimple_match_cond | |
47 { | |
48 enum uncond { UNCOND }; | |
49 | |
50 /* Build an unconditional op. */ | |
51 gimple_match_cond (uncond) : cond (NULL_TREE), else_value (NULL_TREE) {} | |
52 gimple_match_cond (tree, tree); | |
53 | |
54 gimple_match_cond any_else () const; | |
55 | |
56 /* The condition under which the operation occurs, or NULL_TREE | |
57 if the operation is unconditional. */ | |
58 tree cond; | |
59 | |
60 /* The value to use when the condition is false. This is NULL_TREE if | |
61 the operation is unconditional or if the value doesn't matter. */ | |
62 tree else_value; | |
63 }; | |
64 | |
65 inline | |
66 gimple_match_cond::gimple_match_cond (tree cond_in, tree else_value_in) | |
67 : cond (cond_in), else_value (else_value_in) | |
68 { | |
69 } | |
70 | |
71 /* Return a gimple_match_cond with the same condition but with an | |
72 arbitrary ELSE_VALUE. */ | |
73 | |
74 inline gimple_match_cond | |
75 gimple_match_cond::any_else () const | |
76 { | |
77 return gimple_match_cond (cond, NULL_TREE); | |
78 } | |
79 | |
80 /* Represents an operation to be simplified, or the result of the | |
81 simplification. */ | |
82 struct gimple_match_op | |
83 { | |
84 gimple_match_op (); | |
85 gimple_match_op (const gimple_match_cond &, code_helper, tree, unsigned int); | |
86 gimple_match_op (const gimple_match_cond &, | |
87 code_helper, tree, tree); | |
88 gimple_match_op (const gimple_match_cond &, | |
89 code_helper, tree, tree, tree); | |
90 gimple_match_op (const gimple_match_cond &, | |
91 code_helper, tree, tree, tree, tree); | |
92 gimple_match_op (const gimple_match_cond &, | |
93 code_helper, tree, tree, tree, tree, tree); | |
94 gimple_match_op (const gimple_match_cond &, | |
95 code_helper, tree, tree, tree, tree, tree, tree); | |
96 | |
97 void set_op (code_helper, tree, unsigned int); | |
98 void set_op (code_helper, tree, tree); | |
99 void set_op (code_helper, tree, tree, tree); | |
100 void set_op (code_helper, tree, tree, tree, tree); | |
101 void set_op (code_helper, tree, tree, tree, tree, bool); | |
102 void set_op (code_helper, tree, tree, tree, tree, tree); | |
103 void set_op (code_helper, tree, tree, tree, tree, tree, tree); | |
104 void set_value (tree); | |
105 | |
106 tree op_or_null (unsigned int) const; | |
107 | |
108 /* The maximum value of NUM_OPS. */ | |
109 static const unsigned int MAX_NUM_OPS = 5; | |
110 | |
111 /* The conditions under which the operation is performed, and the value to | |
112 use as a fallback. */ | |
113 gimple_match_cond cond; | |
114 | |
115 /* The operation being performed. */ | |
116 code_helper code; | |
117 | |
118 /* The type of the result. */ | |
119 tree type; | |
120 | |
121 /* For a BIT_FIELD_REF, whether the group of bits is stored in reverse order | |
122 from the target order. */ | |
123 bool reverse; | |
124 | |
125 /* The number of operands to CODE. */ | |
126 unsigned int num_ops; | |
127 | |
128 /* The operands to CODE. Only the first NUM_OPS entries are meaningful. */ | |
129 tree ops[MAX_NUM_OPS]; | |
130 }; | |
131 | |
132 inline | |
133 gimple_match_op::gimple_match_op () | |
134 : cond (gimple_match_cond::UNCOND), type (NULL_TREE), reverse (false), | |
135 num_ops (0) | |
136 { | |
137 } | |
138 | |
139 /* Constructor that takes the condition, code, type and number of | |
140 operands, but leaves the caller to fill in the operands. */ | |
141 | |
142 inline | |
143 gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in, | |
144 code_helper code_in, tree type_in, | |
145 unsigned int num_ops_in) | |
146 : cond (cond_in), code (code_in), type (type_in), reverse (false), | |
147 num_ops (num_ops_in) | |
148 { | |
149 } | |
150 | |
151 /* Constructors for various numbers of operands. */ | |
152 | |
153 inline | |
154 gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in, | |
155 code_helper code_in, tree type_in, | |
156 tree op0) | |
157 : cond (cond_in), code (code_in), type (type_in), reverse (false), | |
158 num_ops (1) | |
159 { | |
160 ops[0] = op0; | |
161 } | |
162 | |
163 inline | |
164 gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in, | |
165 code_helper code_in, tree type_in, | |
166 tree op0, tree op1) | |
167 : cond (cond_in), code (code_in), type (type_in), reverse (false), | |
168 num_ops (2) | |
169 { | |
170 ops[0] = op0; | |
171 ops[1] = op1; | |
172 } | |
173 | |
174 inline | |
175 gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in, | |
176 code_helper code_in, tree type_in, | |
177 tree op0, tree op1, tree op2) | |
178 : cond (cond_in), code (code_in), type (type_in), reverse (false), | |
179 num_ops (3) | |
180 { | |
181 ops[0] = op0; | |
182 ops[1] = op1; | |
183 ops[2] = op2; | |
184 } | |
185 | |
186 inline | |
187 gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in, | |
188 code_helper code_in, tree type_in, | |
189 tree op0, tree op1, tree op2, tree op3) | |
190 : cond (cond_in), code (code_in), type (type_in), reverse (false), | |
191 num_ops (4) | |
192 { | |
193 ops[0] = op0; | |
194 ops[1] = op1; | |
195 ops[2] = op2; | |
196 ops[3] = op3; | |
197 } | |
198 | |
199 inline | |
200 gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in, | |
201 code_helper code_in, tree type_in, | |
202 tree op0, tree op1, tree op2, tree op3, | |
203 tree op4) | |
204 : cond (cond_in), code (code_in), type (type_in), reverse (false), | |
205 num_ops (5) | |
206 { | |
207 ops[0] = op0; | |
208 ops[1] = op1; | |
209 ops[2] = op2; | |
210 ops[3] = op3; | |
211 ops[4] = op4; | |
212 } | |
213 | |
214 /* Change the operation performed to CODE_IN, the type of the result to | |
215 TYPE_IN, and the number of operands to NUM_OPS_IN. The caller needs | |
216 to set the operands itself. */ | |
217 | |
218 inline void | |
219 gimple_match_op::set_op (code_helper code_in, tree type_in, | |
220 unsigned int num_ops_in) | |
221 { | |
222 code = code_in; | |
223 type = type_in; | |
224 num_ops = num_ops_in; | |
225 } | |
226 | |
227 /* Functions for changing the operation performed, for various numbers | |
228 of operands. */ | |
229 | |
230 inline void | |
231 gimple_match_op::set_op (code_helper code_in, tree type_in, tree op0) | |
232 { | |
233 code = code_in; | |
234 type = type_in; | |
235 num_ops = 1; | |
236 ops[0] = op0; | |
237 } | |
238 | |
239 inline void | |
240 gimple_match_op::set_op (code_helper code_in, tree type_in, tree op0, tree op1) | |
241 { | |
242 code = code_in; | |
243 type = type_in; | |
244 num_ops = 2; | |
245 ops[0] = op0; | |
246 ops[1] = op1; | |
247 } | |
248 | |
249 inline void | |
250 gimple_match_op::set_op (code_helper code_in, tree type_in, | |
251 tree op0, tree op1, tree op2) | |
252 { | |
253 code = code_in; | |
254 type = type_in; | |
255 num_ops = 3; | |
256 ops[0] = op0; | |
257 ops[1] = op1; | |
258 ops[2] = op2; | |
259 } | |
260 | |
261 inline void | |
262 gimple_match_op::set_op (code_helper code_in, tree type_in, | |
263 tree op0, tree op1, tree op2, bool reverse_in) | |
264 { | |
265 code = code_in; | |
266 type = type_in; | |
267 reverse = reverse_in; | |
268 num_ops = 3; | |
269 ops[0] = op0; | |
270 ops[1] = op1; | |
271 ops[2] = op2; | |
272 } | |
273 | |
274 inline void | |
275 gimple_match_op::set_op (code_helper code_in, tree type_in, | |
276 tree op0, tree op1, tree op2, tree op3) | |
277 { | |
278 code = code_in; | |
279 type = type_in; | |
280 num_ops = 4; | |
281 ops[0] = op0; | |
282 ops[1] = op1; | |
283 ops[2] = op2; | |
284 ops[3] = op3; | |
285 } | |
286 | |
287 inline void | |
288 gimple_match_op::set_op (code_helper code_in, tree type_in, | |
289 tree op0, tree op1, tree op2, tree op3, tree op4) | |
290 { | |
291 code = code_in; | |
292 type = type_in; | |
293 num_ops = 5; | |
294 ops[0] = op0; | |
295 ops[1] = op1; | |
296 ops[2] = op2; | |
297 ops[3] = op3; | |
298 ops[4] = op4; | |
299 } | |
300 | |
301 /* Set the "operation" to be the single value VALUE, such as a constant | |
302 or SSA_NAME. */ | |
303 | |
304 inline void | |
305 gimple_match_op::set_value (tree value) | |
306 { | |
307 set_op (TREE_CODE (value), TREE_TYPE (value), value); | |
308 } | |
309 | |
310 /* Return the value of operand I, or null if there aren't that many | |
311 operands. */ | |
312 | |
313 inline tree | |
314 gimple_match_op::op_or_null (unsigned int i) const | |
315 { | |
316 return i < num_ops ? ops[i] : NULL_TREE; | |
317 } | |
318 | |
319 /* Return whether OP is a non-expression result and a gimple value. */ | |
45 | 320 |
46 inline bool | 321 inline bool |
47 gimple_simplified_result_is_gimple_val (code_helper code, tree *ops) | 322 gimple_simplified_result_is_gimple_val (const gimple_match_op *op) |
48 { | 323 { |
49 return (code.is_tree_code () | 324 return (op->code.is_tree_code () |
50 && (TREE_CODE_LENGTH ((tree_code) code) == 0 | 325 && (TREE_CODE_LENGTH ((tree_code) op->code) == 0 |
51 || ((tree_code) code) == ADDR_EXPR) | 326 || ((tree_code) op->code) == ADDR_EXPR) |
52 && is_gimple_val (ops[0])); | 327 && is_gimple_val (op->ops[0])); |
53 } | 328 } |
54 | 329 |
55 extern tree (*mprts_hook) (code_helper, tree, tree *); | 330 extern tree (*mprts_hook) (gimple_match_op *); |
56 | 331 |
57 bool gimple_simplify (gimple *, code_helper *, tree *, gimple_seq *, | 332 bool gimple_simplify (gimple *, gimple_match_op *, gimple_seq *, |
58 tree (*)(tree), tree (*)(tree)); | 333 tree (*)(tree), tree (*)(tree)); |
59 bool gimple_resimplify1 (gimple_seq *, code_helper *, tree, tree *, | 334 bool gimple_resimplify1 (gimple_seq *, gimple_match_op *, tree (*)(tree)); |
60 tree (*)(tree)); | 335 bool gimple_resimplify2 (gimple_seq *, gimple_match_op *, tree (*)(tree)); |
61 bool gimple_resimplify2 (gimple_seq *, code_helper *, tree, tree *, | 336 bool gimple_resimplify3 (gimple_seq *, gimple_match_op *, tree (*)(tree)); |
62 tree (*)(tree)); | 337 bool gimple_resimplify4 (gimple_seq *, gimple_match_op *, tree (*)(tree)); |
63 bool gimple_resimplify3 (gimple_seq *, code_helper *, tree, tree *, | 338 bool gimple_resimplify5 (gimple_seq *, gimple_match_op *, tree (*)(tree)); |
64 tree (*)(tree)); | 339 tree maybe_push_res_to_seq (gimple_match_op *, gimple_seq *, |
65 tree maybe_push_res_to_seq (code_helper, tree, tree *, | 340 tree res = NULL_TREE); |
66 gimple_seq *, tree res = NULL_TREE); | 341 void maybe_build_generic_op (gimple_match_op *); |
67 void maybe_build_generic_op (enum tree_code, tree, tree *); | |
68 | 342 |
69 | 343 |
70 #endif /* GCC_GIMPLE_MATCH_H */ | 344 #endif /* GCC_GIMPLE_MATCH_H */ |