]>
Commit | Line | Data |
---|---|---|
2a0603f1 AM |
1 | /* Gimple decl, type, and expression support functions. |
2 | ||
23a5b65a | 3 | Copyright (C) 2007-2014 Free Software Foundation, Inc. |
2a0603f1 AM |
4 | Contributed by Aldy Hernandez <aldyh@redhat.com> |
5 | ||
6 | This file is part of GCC. | |
7 | ||
8 | GCC is free software; you can redistribute it and/or modify it under | |
9 | the terms of the GNU General Public License as published by the Free | |
10 | Software Foundation; either version 3, or (at your option) any later | |
11 | version. | |
12 | ||
13 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
14 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 | for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with GCC; see the file COPYING3. If not see | |
20 | <http://www.gnu.org/licenses/>. */ | |
21 | ||
22 | #include "config.h" | |
23 | #include "system.h" | |
24 | #include "coretypes.h" | |
25 | #include "tm.h" | |
26 | #include "tree.h" | |
2fb9a547 AM |
27 | #include "pointer-set.h" |
28 | #include "basic-block.h" | |
29 | #include "tree-ssa-alias.h" | |
30 | #include "internal-fn.h" | |
31 | #include "tree-eh.h" | |
32 | #include "gimple-expr.h" | |
33 | #include "is-a.h" | |
18f429e2 | 34 | #include "gimple.h" |
d8a2d370 | 35 | #include "stringpool.h" |
45b0be94 | 36 | #include "gimplify.h" |
d8a2d370 | 37 | #include "stor-layout.h" |
2a0603f1 | 38 | #include "demangle.h" |
45b0be94 | 39 | #include "gimple-ssa.h" |
2a0603f1 AM |
40 | |
41 | /* ----- Type related ----- */ | |
42 | ||
43 | /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a | |
44 | useless type conversion, otherwise return false. | |
45 | ||
46 | This function implicitly defines the middle-end type system. With | |
47 | the notion of 'a < b' meaning that useless_type_conversion_p (a, b) | |
48 | holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds, | |
49 | the following invariants shall be fulfilled: | |
50 | ||
51 | 1) useless_type_conversion_p is transitive. | |
52 | If a < b and b < c then a < c. | |
53 | ||
54 | 2) useless_type_conversion_p is not symmetric. | |
55 | From a < b does not follow a > b. | |
56 | ||
57 | 3) Types define the available set of operations applicable to values. | |
58 | A type conversion is useless if the operations for the target type | |
59 | is a subset of the operations for the source type. For example | |
60 | casts to void* are useless, casts from void* are not (void* can't | |
61 | be dereferenced or offsetted, but copied, hence its set of operations | |
62 | is a strict subset of that of all other data pointer types). Casts | |
63 | to const T* are useless (can't be written to), casts from const T* | |
64 | to T* are not. */ | |
65 | ||
66 | bool | |
67 | useless_type_conversion_p (tree outer_type, tree inner_type) | |
68 | { | |
69 | /* Do the following before stripping toplevel qualifiers. */ | |
70 | if (POINTER_TYPE_P (inner_type) | |
71 | && POINTER_TYPE_P (outer_type)) | |
72 | { | |
73 | /* Do not lose casts between pointers to different address spaces. */ | |
74 | if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type)) | |
75 | != TYPE_ADDR_SPACE (TREE_TYPE (inner_type))) | |
76 | return false; | |
77 | } | |
78 | ||
79 | /* From now on qualifiers on value types do not matter. */ | |
80 | inner_type = TYPE_MAIN_VARIANT (inner_type); | |
81 | outer_type = TYPE_MAIN_VARIANT (outer_type); | |
82 | ||
83 | if (inner_type == outer_type) | |
84 | return true; | |
85 | ||
86 | /* If we know the canonical types, compare them. */ | |
87 | if (TYPE_CANONICAL (inner_type) | |
88 | && TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type)) | |
89 | return true; | |
90 | ||
91 | /* Changes in machine mode are never useless conversions unless we | |
92 | deal with aggregate types in which case we defer to later checks. */ | |
93 | if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type) | |
94 | && !AGGREGATE_TYPE_P (inner_type)) | |
95 | return false; | |
96 | ||
97 | /* If both the inner and outer types are integral types, then the | |
98 | conversion is not necessary if they have the same mode and | |
99 | signedness and precision, and both or neither are boolean. */ | |
100 | if (INTEGRAL_TYPE_P (inner_type) | |
101 | && INTEGRAL_TYPE_P (outer_type)) | |
102 | { | |
103 | /* Preserve changes in signedness or precision. */ | |
104 | if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type) | |
105 | || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type)) | |
106 | return false; | |
107 | ||
108 | /* Preserve conversions to/from BOOLEAN_TYPE if types are not | |
109 | of precision one. */ | |
110 | if (((TREE_CODE (inner_type) == BOOLEAN_TYPE) | |
111 | != (TREE_CODE (outer_type) == BOOLEAN_TYPE)) | |
112 | && TYPE_PRECISION (outer_type) != 1) | |
113 | return false; | |
114 | ||
115 | /* We don't need to preserve changes in the types minimum or | |
116 | maximum value in general as these do not generate code | |
117 | unless the types precisions are different. */ | |
118 | return true; | |
119 | } | |
120 | ||
121 | /* Scalar floating point types with the same mode are compatible. */ | |
122 | else if (SCALAR_FLOAT_TYPE_P (inner_type) | |
123 | && SCALAR_FLOAT_TYPE_P (outer_type)) | |
124 | return true; | |
125 | ||
126 | /* Fixed point types with the same mode are compatible. */ | |
127 | else if (FIXED_POINT_TYPE_P (inner_type) | |
128 | && FIXED_POINT_TYPE_P (outer_type)) | |
129 | return true; | |
130 | ||
131 | /* We need to take special care recursing to pointed-to types. */ | |
132 | else if (POINTER_TYPE_P (inner_type) | |
133 | && POINTER_TYPE_P (outer_type)) | |
134 | { | |
135 | /* Do not lose casts to function pointer types. */ | |
136 | if ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE | |
137 | || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE) | |
138 | && !(TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE | |
139 | || TREE_CODE (TREE_TYPE (inner_type)) == METHOD_TYPE)) | |
140 | return false; | |
141 | ||
142 | /* We do not care for const qualification of the pointed-to types | |
143 | as const qualification has no semantic value to the middle-end. */ | |
144 | ||
145 | /* Otherwise pointers/references are equivalent. */ | |
146 | return true; | |
147 | } | |
148 | ||
149 | /* Recurse for complex types. */ | |
150 | else if (TREE_CODE (inner_type) == COMPLEX_TYPE | |
151 | && TREE_CODE (outer_type) == COMPLEX_TYPE) | |
152 | return useless_type_conversion_p (TREE_TYPE (outer_type), | |
153 | TREE_TYPE (inner_type)); | |
154 | ||
155 | /* Recurse for vector types with the same number of subparts. */ | |
156 | else if (TREE_CODE (inner_type) == VECTOR_TYPE | |
157 | && TREE_CODE (outer_type) == VECTOR_TYPE | |
158 | && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type)) | |
159 | return useless_type_conversion_p (TREE_TYPE (outer_type), | |
160 | TREE_TYPE (inner_type)); | |
161 | ||
162 | else if (TREE_CODE (inner_type) == ARRAY_TYPE | |
163 | && TREE_CODE (outer_type) == ARRAY_TYPE) | |
164 | { | |
165 | /* Preserve string attributes. */ | |
166 | if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type)) | |
167 | return false; | |
168 | ||
169 | /* Conversions from array types with unknown extent to | |
170 | array types with known extent are not useless. */ | |
171 | if (!TYPE_DOMAIN (inner_type) | |
172 | && TYPE_DOMAIN (outer_type)) | |
173 | return false; | |
174 | ||
175 | /* Nor are conversions from array types with non-constant size to | |
176 | array types with constant size or to different size. */ | |
177 | if (TYPE_SIZE (outer_type) | |
178 | && TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST | |
179 | && (!TYPE_SIZE (inner_type) | |
180 | || TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST | |
181 | || !tree_int_cst_equal (TYPE_SIZE (outer_type), | |
182 | TYPE_SIZE (inner_type)))) | |
183 | return false; | |
184 | ||
185 | /* Check conversions between arrays with partially known extents. | |
186 | If the array min/max values are constant they have to match. | |
187 | Otherwise allow conversions to unknown and variable extents. | |
188 | In particular this declares conversions that may change the | |
189 | mode to BLKmode as useless. */ | |
190 | if (TYPE_DOMAIN (inner_type) | |
191 | && TYPE_DOMAIN (outer_type) | |
192 | && TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type)) | |
193 | { | |
194 | tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type)); | |
195 | tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type)); | |
196 | tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type)); | |
197 | tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type)); | |
198 | ||
199 | /* After gimplification a variable min/max value carries no | |
200 | additional information compared to a NULL value. All that | |
201 | matters has been lowered to be part of the IL. */ | |
202 | if (inner_min && TREE_CODE (inner_min) != INTEGER_CST) | |
203 | inner_min = NULL_TREE; | |
204 | if (outer_min && TREE_CODE (outer_min) != INTEGER_CST) | |
205 | outer_min = NULL_TREE; | |
206 | if (inner_max && TREE_CODE (inner_max) != INTEGER_CST) | |
207 | inner_max = NULL_TREE; | |
208 | if (outer_max && TREE_CODE (outer_max) != INTEGER_CST) | |
209 | outer_max = NULL_TREE; | |
210 | ||
211 | /* Conversions NULL / variable <- cst are useless, but not | |
212 | the other way around. */ | |
213 | if (outer_min | |
214 | && (!inner_min | |
215 | || !tree_int_cst_equal (inner_min, outer_min))) | |
216 | return false; | |
217 | if (outer_max | |
218 | && (!inner_max | |
219 | || !tree_int_cst_equal (inner_max, outer_max))) | |
220 | return false; | |
221 | } | |
222 | ||
223 | /* Recurse on the element check. */ | |
224 | return useless_type_conversion_p (TREE_TYPE (outer_type), | |
225 | TREE_TYPE (inner_type)); | |
226 | } | |
227 | ||
228 | else if ((TREE_CODE (inner_type) == FUNCTION_TYPE | |
229 | || TREE_CODE (inner_type) == METHOD_TYPE) | |
230 | && TREE_CODE (inner_type) == TREE_CODE (outer_type)) | |
231 | { | |
232 | tree outer_parm, inner_parm; | |
233 | ||
234 | /* If the return types are not compatible bail out. */ | |
235 | if (!useless_type_conversion_p (TREE_TYPE (outer_type), | |
236 | TREE_TYPE (inner_type))) | |
237 | return false; | |
238 | ||
239 | /* Method types should belong to a compatible base class. */ | |
240 | if (TREE_CODE (inner_type) == METHOD_TYPE | |
241 | && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type), | |
242 | TYPE_METHOD_BASETYPE (inner_type))) | |
243 | return false; | |
244 | ||
245 | /* A conversion to an unprototyped argument list is ok. */ | |
246 | if (!prototype_p (outer_type)) | |
247 | return true; | |
248 | ||
249 | /* If the unqualified argument types are compatible the conversion | |
250 | is useless. */ | |
251 | if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type)) | |
252 | return true; | |
253 | ||
254 | for (outer_parm = TYPE_ARG_TYPES (outer_type), | |
255 | inner_parm = TYPE_ARG_TYPES (inner_type); | |
256 | outer_parm && inner_parm; | |
257 | outer_parm = TREE_CHAIN (outer_parm), | |
258 | inner_parm = TREE_CHAIN (inner_parm)) | |
259 | if (!useless_type_conversion_p | |
260 | (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm)), | |
261 | TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm)))) | |
262 | return false; | |
263 | ||
264 | /* If there is a mismatch in the number of arguments the functions | |
265 | are not compatible. */ | |
266 | if (outer_parm || inner_parm) | |
267 | return false; | |
268 | ||
269 | /* Defer to the target if necessary. */ | |
270 | if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type)) | |
271 | return comp_type_attributes (outer_type, inner_type) != 0; | |
272 | ||
273 | return true; | |
274 | } | |
275 | ||
276 | /* For aggregates we rely on TYPE_CANONICAL exclusively and require | |
277 | explicit conversions for types involving to be structurally | |
278 | compared types. */ | |
279 | else if (AGGREGATE_TYPE_P (inner_type) | |
280 | && TREE_CODE (inner_type) == TREE_CODE (outer_type)) | |
281 | return false; | |
282 | ||
283 | return false; | |
284 | } | |
285 | ||
286 | ||
287 | /* ----- Decl related ----- */ | |
288 | ||
289 | /* Set sequence SEQ to be the GIMPLE body for function FN. */ | |
290 | ||
291 | void | |
292 | gimple_set_body (tree fndecl, gimple_seq seq) | |
293 | { | |
294 | struct function *fn = DECL_STRUCT_FUNCTION (fndecl); | |
295 | if (fn == NULL) | |
296 | { | |
297 | /* If FNDECL still does not have a function structure associated | |
298 | with it, then it does not make sense for it to receive a | |
299 | GIMPLE body. */ | |
300 | gcc_assert (seq == NULL); | |
301 | } | |
302 | else | |
303 | fn->gimple_body = seq; | |
304 | } | |
305 | ||
306 | ||
307 | /* Return the body of GIMPLE statements for function FN. After the | |
308 | CFG pass, the function body doesn't exist anymore because it has | |
309 | been split up into basic blocks. In this case, it returns | |
310 | NULL. */ | |
311 | ||
312 | gimple_seq | |
313 | gimple_body (tree fndecl) | |
314 | { | |
315 | struct function *fn = DECL_STRUCT_FUNCTION (fndecl); | |
316 | return fn ? fn->gimple_body : NULL; | |
317 | } | |
318 | ||
319 | /* Return true when FNDECL has Gimple body either in unlowered | |
320 | or CFG form. */ | |
321 | bool | |
322 | gimple_has_body_p (tree fndecl) | |
323 | { | |
324 | struct function *fn = DECL_STRUCT_FUNCTION (fndecl); | |
325 | return (gimple_body (fndecl) || (fn && fn->cfg)); | |
326 | } | |
327 | ||
328 | /* Return a printable name for symbol DECL. */ | |
329 | ||
330 | const char * | |
331 | gimple_decl_printable_name (tree decl, int verbosity) | |
332 | { | |
333 | if (!DECL_NAME (decl)) | |
334 | return NULL; | |
335 | ||
336 | if (DECL_ASSEMBLER_NAME_SET_P (decl)) | |
337 | { | |
338 | const char *str, *mangled_str; | |
339 | int dmgl_opts = DMGL_NO_OPTS; | |
340 | ||
341 | if (verbosity >= 2) | |
342 | { | |
343 | dmgl_opts = DMGL_VERBOSE | |
344 | | DMGL_ANSI | |
345 | | DMGL_GNU_V3 | |
346 | | DMGL_RET_POSTFIX; | |
347 | if (TREE_CODE (decl) == FUNCTION_DECL) | |
348 | dmgl_opts |= DMGL_PARAMS; | |
349 | } | |
350 | ||
351 | mangled_str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); | |
352 | str = cplus_demangle_v3 (mangled_str, dmgl_opts); | |
353 | return (str) ? str : mangled_str; | |
354 | } | |
355 | ||
356 | return IDENTIFIER_POINTER (DECL_NAME (decl)); | |
357 | } | |
358 | ||
359 | ||
360 | /* Create a new VAR_DECL and copy information from VAR to it. */ | |
361 | ||
362 | tree | |
363 | copy_var_decl (tree var, tree name, tree type) | |
364 | { | |
365 | tree copy = build_decl (DECL_SOURCE_LOCATION (var), VAR_DECL, name, type); | |
366 | ||
367 | TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (var); | |
368 | TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (var); | |
369 | DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (var); | |
370 | DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (var); | |
371 | DECL_IGNORED_P (copy) = DECL_IGNORED_P (var); | |
372 | DECL_CONTEXT (copy) = DECL_CONTEXT (var); | |
373 | TREE_NO_WARNING (copy) = TREE_NO_WARNING (var); | |
374 | TREE_USED (copy) = 1; | |
375 | DECL_SEEN_IN_BIND_EXPR_P (copy) = 1; | |
376 | DECL_ATTRIBUTES (copy) = DECL_ATTRIBUTES (var); | |
377 | ||
378 | return copy; | |
379 | } | |
380 | ||
381 | /* Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for | |
382 | coalescing together, false otherwise. | |
383 | ||
384 | This must stay consistent with var_map_base_init in tree-ssa-live.c. */ | |
385 | ||
386 | bool | |
387 | gimple_can_coalesce_p (tree name1, tree name2) | |
388 | { | |
389 | /* First check the SSA_NAME's associated DECL. We only want to | |
390 | coalesce if they have the same DECL or both have no associated DECL. */ | |
391 | tree var1 = SSA_NAME_VAR (name1); | |
392 | tree var2 = SSA_NAME_VAR (name2); | |
393 | var1 = (var1 && (!VAR_P (var1) || !DECL_IGNORED_P (var1))) ? var1 : NULL_TREE; | |
394 | var2 = (var2 && (!VAR_P (var2) || !DECL_IGNORED_P (var2))) ? var2 : NULL_TREE; | |
395 | if (var1 != var2) | |
396 | return false; | |
397 | ||
398 | /* Now check the types. If the types are the same, then we should | |
399 | try to coalesce V1 and V2. */ | |
400 | tree t1 = TREE_TYPE (name1); | |
401 | tree t2 = TREE_TYPE (name2); | |
402 | if (t1 == t2) | |
403 | return true; | |
404 | ||
405 | /* If the types are not the same, check for a canonical type match. This | |
406 | (for example) allows coalescing when the types are fundamentally the | |
407 | same, but just have different names. | |
408 | ||
409 | Note pointer types with different address spaces may have the same | |
410 | canonical type. Those are rejected for coalescing by the | |
411 | types_compatible_p check. */ | |
412 | if (TYPE_CANONICAL (t1) | |
413 | && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2) | |
414 | && types_compatible_p (t1, t2)) | |
415 | return true; | |
416 | ||
417 | return false; | |
418 | } | |
419 | ||
45b0be94 AM |
420 | /* Strip off a legitimate source ending from the input string NAME of |
421 | length LEN. Rather than having to know the names used by all of | |
422 | our front ends, we strip off an ending of a period followed by | |
423 | up to five characters. (Java uses ".class".) */ | |
424 | ||
425 | static inline void | |
426 | remove_suffix (char *name, int len) | |
427 | { | |
428 | int i; | |
429 | ||
430 | for (i = 2; i < 8 && len > i; i++) | |
431 | { | |
432 | if (name[len - i] == '.') | |
433 | { | |
434 | name[len - i] = '\0'; | |
435 | break; | |
436 | } | |
437 | } | |
438 | } | |
439 | ||
440 | /* Create a new temporary name with PREFIX. Return an identifier. */ | |
441 | ||
442 | static GTY(()) unsigned int tmp_var_id_num; | |
443 | ||
444 | tree | |
445 | create_tmp_var_name (const char *prefix) | |
446 | { | |
447 | char *tmp_name; | |
448 | ||
449 | if (prefix) | |
450 | { | |
451 | char *preftmp = ASTRDUP (prefix); | |
452 | ||
453 | remove_suffix (preftmp, strlen (preftmp)); | |
454 | clean_symbol_name (preftmp); | |
455 | ||
456 | prefix = preftmp; | |
457 | } | |
458 | ||
459 | ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++); | |
460 | return get_identifier (tmp_name); | |
461 | } | |
462 | ||
463 | /* Create a new temporary variable declaration of type TYPE. | |
464 | Do NOT push it into the current binding. */ | |
465 | ||
466 | tree | |
467 | create_tmp_var_raw (tree type, const char *prefix) | |
468 | { | |
469 | tree tmp_var; | |
470 | ||
471 | tmp_var = build_decl (input_location, | |
472 | VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL, | |
473 | type); | |
474 | ||
475 | /* The variable was declared by the compiler. */ | |
476 | DECL_ARTIFICIAL (tmp_var) = 1; | |
477 | /* And we don't want debug info for it. */ | |
478 | DECL_IGNORED_P (tmp_var) = 1; | |
479 | ||
480 | /* Make the variable writable. */ | |
481 | TREE_READONLY (tmp_var) = 0; | |
482 | ||
483 | DECL_EXTERNAL (tmp_var) = 0; | |
484 | TREE_STATIC (tmp_var) = 0; | |
485 | TREE_USED (tmp_var) = 1; | |
486 | ||
487 | return tmp_var; | |
488 | } | |
489 | ||
490 | /* Create a new temporary variable declaration of type TYPE. DO push the | |
491 | variable into the current binding. Further, assume that this is called | |
492 | only from gimplification or optimization, at which point the creation of | |
493 | certain types are bugs. */ | |
494 | ||
495 | tree | |
496 | create_tmp_var (tree type, const char *prefix) | |
497 | { | |
498 | tree tmp_var; | |
499 | ||
500 | /* We don't allow types that are addressable (meaning we can't make copies), | |
501 | or incomplete. We also used to reject every variable size objects here, | |
502 | but now support those for which a constant upper bound can be obtained. | |
503 | The processing for variable sizes is performed in gimple_add_tmp_var, | |
504 | point at which it really matters and possibly reached via paths not going | |
505 | through this function, e.g. after direct calls to create_tmp_var_raw. */ | |
506 | gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type)); | |
507 | ||
508 | tmp_var = create_tmp_var_raw (type, prefix); | |
509 | gimple_add_tmp_var (tmp_var); | |
510 | return tmp_var; | |
511 | } | |
512 | ||
513 | /* Create a new temporary variable declaration of type TYPE by calling | |
514 | create_tmp_var and if TYPE is a vector or a complex number, mark the new | |
515 | temporary as gimple register. */ | |
516 | ||
517 | tree | |
518 | create_tmp_reg (tree type, const char *prefix) | |
519 | { | |
520 | tree tmp; | |
521 | ||
522 | tmp = create_tmp_var (type, prefix); | |
523 | if (TREE_CODE (type) == COMPLEX_TYPE | |
524 | || TREE_CODE (type) == VECTOR_TYPE) | |
525 | DECL_GIMPLE_REG_P (tmp) = 1; | |
526 | ||
527 | return tmp; | |
528 | } | |
529 | ||
2a0603f1 AM |
530 | |
531 | /* ----- Expression related ----- */ | |
532 | ||
533 | /* Extract the operands and code for expression EXPR into *SUBCODE_P, | |
534 | *OP1_P, *OP2_P and *OP3_P respectively. */ | |
535 | ||
536 | void | |
537 | extract_ops_from_tree_1 (tree expr, enum tree_code *subcode_p, tree *op1_p, | |
538 | tree *op2_p, tree *op3_p) | |
539 | { | |
540 | enum gimple_rhs_class grhs_class; | |
541 | ||
542 | *subcode_p = TREE_CODE (expr); | |
543 | grhs_class = get_gimple_rhs_class (*subcode_p); | |
544 | ||
545 | if (grhs_class == GIMPLE_TERNARY_RHS) | |
546 | { | |
547 | *op1_p = TREE_OPERAND (expr, 0); | |
548 | *op2_p = TREE_OPERAND (expr, 1); | |
549 | *op3_p = TREE_OPERAND (expr, 2); | |
550 | } | |
551 | else if (grhs_class == GIMPLE_BINARY_RHS) | |
552 | { | |
553 | *op1_p = TREE_OPERAND (expr, 0); | |
554 | *op2_p = TREE_OPERAND (expr, 1); | |
555 | *op3_p = NULL_TREE; | |
556 | } | |
557 | else if (grhs_class == GIMPLE_UNARY_RHS) | |
558 | { | |
559 | *op1_p = TREE_OPERAND (expr, 0); | |
560 | *op2_p = NULL_TREE; | |
561 | *op3_p = NULL_TREE; | |
562 | } | |
563 | else if (grhs_class == GIMPLE_SINGLE_RHS) | |
564 | { | |
565 | *op1_p = expr; | |
566 | *op2_p = NULL_TREE; | |
567 | *op3_p = NULL_TREE; | |
568 | } | |
569 | else | |
570 | gcc_unreachable (); | |
571 | } | |
572 | ||
573 | /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */ | |
574 | ||
575 | void | |
576 | gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p, | |
577 | tree *lhs_p, tree *rhs_p) | |
578 | { | |
579 | gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison | |
580 | || TREE_CODE (cond) == TRUTH_NOT_EXPR | |
581 | || is_gimple_min_invariant (cond) | |
582 | || SSA_VAR_P (cond)); | |
583 | ||
584 | extract_ops_from_tree (cond, code_p, lhs_p, rhs_p); | |
585 | ||
586 | /* Canonicalize conditionals of the form 'if (!VAL)'. */ | |
587 | if (*code_p == TRUTH_NOT_EXPR) | |
588 | { | |
589 | *code_p = EQ_EXPR; | |
590 | gcc_assert (*lhs_p && *rhs_p == NULL_TREE); | |
591 | *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p)); | |
592 | } | |
593 | /* Canonicalize conditionals of the form 'if (VAL)' */ | |
594 | else if (TREE_CODE_CLASS (*code_p) != tcc_comparison) | |
595 | { | |
596 | *code_p = NE_EXPR; | |
597 | gcc_assert (*lhs_p && *rhs_p == NULL_TREE); | |
598 | *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p)); | |
599 | } | |
600 | } | |
601 | ||
602 | /* Return true if T is a valid LHS for a GIMPLE assignment expression. */ | |
603 | ||
604 | bool | |
605 | is_gimple_lvalue (tree t) | |
606 | { | |
607 | return (is_gimple_addressable (t) | |
608 | || TREE_CODE (t) == WITH_SIZE_EXPR | |
609 | /* These are complex lvalues, but don't have addresses, so they | |
610 | go here. */ | |
611 | || TREE_CODE (t) == BIT_FIELD_REF); | |
612 | } | |
613 | ||
614 | /* Return true if T is a GIMPLE condition. */ | |
615 | ||
616 | bool | |
617 | is_gimple_condexpr (tree t) | |
618 | { | |
619 | return (is_gimple_val (t) || (COMPARISON_CLASS_P (t) | |
620 | && !tree_could_throw_p (t) | |
621 | && is_gimple_val (TREE_OPERAND (t, 0)) | |
622 | && is_gimple_val (TREE_OPERAND (t, 1)))); | |
623 | } | |
624 | ||
625 | /* Return true if T is a gimple address. */ | |
626 | ||
627 | bool | |
628 | is_gimple_address (const_tree t) | |
629 | { | |
630 | tree op; | |
631 | ||
632 | if (TREE_CODE (t) != ADDR_EXPR) | |
633 | return false; | |
634 | ||
635 | op = TREE_OPERAND (t, 0); | |
636 | while (handled_component_p (op)) | |
637 | { | |
638 | if ((TREE_CODE (op) == ARRAY_REF | |
639 | || TREE_CODE (op) == ARRAY_RANGE_REF) | |
640 | && !is_gimple_val (TREE_OPERAND (op, 1))) | |
641 | return false; | |
642 | ||
643 | op = TREE_OPERAND (op, 0); | |
644 | } | |
645 | ||
646 | if (CONSTANT_CLASS_P (op) || TREE_CODE (op) == MEM_REF) | |
647 | return true; | |
648 | ||
649 | switch (TREE_CODE (op)) | |
650 | { | |
651 | case PARM_DECL: | |
652 | case RESULT_DECL: | |
653 | case LABEL_DECL: | |
654 | case FUNCTION_DECL: | |
655 | case VAR_DECL: | |
656 | case CONST_DECL: | |
657 | return true; | |
658 | ||
659 | default: | |
660 | return false; | |
661 | } | |
662 | } | |
663 | ||
664 | /* Return true if T is a gimple invariant address. */ | |
665 | ||
666 | bool | |
667 | is_gimple_invariant_address (const_tree t) | |
668 | { | |
669 | const_tree op; | |
670 | ||
671 | if (TREE_CODE (t) != ADDR_EXPR) | |
672 | return false; | |
673 | ||
674 | op = strip_invariant_refs (TREE_OPERAND (t, 0)); | |
675 | if (!op) | |
676 | return false; | |
677 | ||
678 | if (TREE_CODE (op) == MEM_REF) | |
679 | { | |
680 | const_tree op0 = TREE_OPERAND (op, 0); | |
681 | return (TREE_CODE (op0) == ADDR_EXPR | |
682 | && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0)) | |
683 | || decl_address_invariant_p (TREE_OPERAND (op0, 0)))); | |
684 | } | |
685 | ||
686 | return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op); | |
687 | } | |
688 | ||
689 | /* Return true if T is a gimple invariant address at IPA level | |
690 | (so addresses of variables on stack are not allowed). */ | |
691 | ||
692 | bool | |
693 | is_gimple_ip_invariant_address (const_tree t) | |
694 | { | |
695 | const_tree op; | |
696 | ||
697 | if (TREE_CODE (t) != ADDR_EXPR) | |
698 | return false; | |
699 | ||
700 | op = strip_invariant_refs (TREE_OPERAND (t, 0)); | |
701 | if (!op) | |
702 | return false; | |
703 | ||
704 | if (TREE_CODE (op) == MEM_REF) | |
705 | { | |
706 | const_tree op0 = TREE_OPERAND (op, 0); | |
707 | return (TREE_CODE (op0) == ADDR_EXPR | |
708 | && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0)) | |
709 | || decl_address_ip_invariant_p (TREE_OPERAND (op0, 0)))); | |
710 | } | |
711 | ||
712 | return CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op); | |
713 | } | |
714 | ||
715 | /* Return true if T is a GIMPLE minimal invariant. It's a restricted | |
716 | form of function invariant. */ | |
717 | ||
718 | bool | |
719 | is_gimple_min_invariant (const_tree t) | |
720 | { | |
721 | if (TREE_CODE (t) == ADDR_EXPR) | |
722 | return is_gimple_invariant_address (t); | |
723 | ||
724 | return is_gimple_constant (t); | |
725 | } | |
726 | ||
727 | /* Return true if T is a GIMPLE interprocedural invariant. It's a restricted | |
728 | form of gimple minimal invariant. */ | |
729 | ||
730 | bool | |
731 | is_gimple_ip_invariant (const_tree t) | |
732 | { | |
733 | if (TREE_CODE (t) == ADDR_EXPR) | |
734 | return is_gimple_ip_invariant_address (t); | |
735 | ||
736 | return is_gimple_constant (t); | |
737 | } | |
738 | ||
739 | /* Return true if T is a non-aggregate register variable. */ | |
740 | ||
741 | bool | |
742 | is_gimple_reg (tree t) | |
743 | { | |
744 | if (virtual_operand_p (t)) | |
745 | return false; | |
746 | ||
747 | if (TREE_CODE (t) == SSA_NAME) | |
748 | return true; | |
749 | ||
750 | if (!is_gimple_variable (t)) | |
751 | return false; | |
752 | ||
753 | if (!is_gimple_reg_type (TREE_TYPE (t))) | |
754 | return false; | |
755 | ||
756 | /* A volatile decl is not acceptable because we can't reuse it as | |
757 | needed. We need to copy it into a temp first. */ | |
758 | if (TREE_THIS_VOLATILE (t)) | |
759 | return false; | |
760 | ||
761 | /* We define "registers" as things that can be renamed as needed, | |
762 | which with our infrastructure does not apply to memory. */ | |
763 | if (needs_to_live_in_memory (t)) | |
764 | return false; | |
765 | ||
766 | /* Hard register variables are an interesting case. For those that | |
767 | are call-clobbered, we don't know where all the calls are, since | |
768 | we don't (want to) take into account which operations will turn | |
769 | into libcalls at the rtl level. For those that are call-saved, | |
770 | we don't currently model the fact that calls may in fact change | |
771 | global hard registers, nor do we examine ASM_CLOBBERS at the tree | |
772 | level, and so miss variable changes that might imply. All around, | |
773 | it seems safest to not do too much optimization with these at the | |
774 | tree level at all. We'll have to rely on the rtl optimizers to | |
775 | clean this up, as there we've got all the appropriate bits exposed. */ | |
776 | if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t)) | |
777 | return false; | |
778 | ||
779 | /* Complex and vector values must have been put into SSA-like form. | |
780 | That is, no assignments to the individual components. */ | |
781 | if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE | |
782 | || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE) | |
783 | return DECL_GIMPLE_REG_P (t); | |
784 | ||
785 | return true; | |
786 | } | |
787 | ||
788 | ||
789 | /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */ | |
790 | ||
791 | bool | |
792 | is_gimple_val (tree t) | |
793 | { | |
794 | /* Make loads from volatiles and memory vars explicit. */ | |
795 | if (is_gimple_variable (t) | |
796 | && is_gimple_reg_type (TREE_TYPE (t)) | |
797 | && !is_gimple_reg (t)) | |
798 | return false; | |
799 | ||
800 | return (is_gimple_variable (t) || is_gimple_min_invariant (t)); | |
801 | } | |
802 | ||
803 | /* Similarly, but accept hard registers as inputs to asm statements. */ | |
804 | ||
805 | bool | |
806 | is_gimple_asm_val (tree t) | |
807 | { | |
808 | if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t)) | |
809 | return true; | |
810 | ||
811 | return is_gimple_val (t); | |
812 | } | |
813 | ||
814 | /* Return true if T is a GIMPLE minimal lvalue. */ | |
815 | ||
816 | bool | |
817 | is_gimple_min_lval (tree t) | |
818 | { | |
819 | if (!(t = CONST_CAST_TREE (strip_invariant_refs (t)))) | |
820 | return false; | |
821 | return (is_gimple_id (t) || TREE_CODE (t) == MEM_REF); | |
822 | } | |
823 | ||
824 | /* Return true if T is a valid function operand of a CALL_EXPR. */ | |
825 | ||
826 | bool | |
827 | is_gimple_call_addr (tree t) | |
828 | { | |
829 | return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t)); | |
830 | } | |
831 | ||
832 | /* Return true if T is a valid address operand of a MEM_REF. */ | |
833 | ||
834 | bool | |
835 | is_gimple_mem_ref_addr (tree t) | |
836 | { | |
837 | return (is_gimple_reg (t) | |
838 | || TREE_CODE (t) == INTEGER_CST | |
839 | || (TREE_CODE (t) == ADDR_EXPR | |
840 | && (CONSTANT_CLASS_P (TREE_OPERAND (t, 0)) | |
841 | || decl_address_invariant_p (TREE_OPERAND (t, 0))))); | |
842 | } | |
45b0be94 AM |
843 | |
844 | /* Mark X addressable. Unlike the langhook we expect X to be in gimple | |
845 | form and we don't do any syntax checking. */ | |
846 | ||
847 | void | |
848 | mark_addressable (tree x) | |
849 | { | |
850 | while (handled_component_p (x)) | |
851 | x = TREE_OPERAND (x, 0); | |
852 | if (TREE_CODE (x) == MEM_REF | |
853 | && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR) | |
854 | x = TREE_OPERAND (TREE_OPERAND (x, 0), 0); | |
855 | if (TREE_CODE (x) != VAR_DECL | |
856 | && TREE_CODE (x) != PARM_DECL | |
857 | && TREE_CODE (x) != RESULT_DECL) | |
858 | return; | |
859 | TREE_ADDRESSABLE (x) = 1; | |
860 | ||
861 | /* Also mark the artificial SSA_NAME that points to the partition of X. */ | |
862 | if (TREE_CODE (x) == VAR_DECL | |
863 | && !DECL_EXTERNAL (x) | |
864 | && !TREE_STATIC (x) | |
865 | && cfun->gimple_df != NULL | |
866 | && cfun->gimple_df->decls_to_pointers != NULL) | |
867 | { | |
868 | void *namep | |
869 | = pointer_map_contains (cfun->gimple_df->decls_to_pointers, x); | |
870 | if (namep) | |
871 | TREE_ADDRESSABLE (*(tree *)namep) = 1; | |
872 | } | |
873 | } | |
874 | ||
875 | /* Returns true iff T is a valid RHS for an assignment to a renamed | |
876 | user -- or front-end generated artificial -- variable. */ | |
877 | ||
878 | bool | |
879 | is_gimple_reg_rhs (tree t) | |
880 | { | |
881 | return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS; | |
882 | } | |
883 | ||
884 | #include "gt-gimple-expr.h" |