1 /* Gimple decl, type, and expression support functions.
3 Copyright (C) 2007-2022 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
28 #include "stringpool.h"
29 #include "gimple-ssa.h"
30 #include "fold-const.h"
33 #include "stor-layout.h"
37 #include "tree-pass.h"
38 #include "stringpool.h"
42 /* ----- Type related ----- */
44 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
45 useless type conversion, otherwise return false.
47 This function implicitly defines the middle-end type system. With
48 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
49 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
50 the following invariants shall be fulfilled:
52 1) useless_type_conversion_p is transitive.
53 If a < b and b < c then a < c.
55 2) useless_type_conversion_p is not symmetric.
56 From a < b does not follow a > b.
58 3) Types define the available set of operations applicable to values.
59 A type conversion is useless if the operations for the target type
60 is a subset of the operations for the source type. For example
61 casts to void* are useless, casts from void* are not (void* can't
62 be dereferenced or offsetted, but copied, hence its set of operations
63 is a strict subset of that of all other data pointer types). Casts
64 to const T* are useless (can't be written to), casts from const T*
68 useless_type_conversion_p (tree outer_type
, tree inner_type
)
70 /* Do the following before stripping toplevel qualifiers. */
71 if (POINTER_TYPE_P (inner_type
)
72 && POINTER_TYPE_P (outer_type
))
74 /* Do not lose casts between pointers to different address spaces. */
75 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
76 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)))
78 /* Do not lose casts to function pointer types. */
79 if ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
80 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
81 && !(TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
82 || TREE_CODE (TREE_TYPE (inner_type
)) == METHOD_TYPE
))
86 /* From now on qualifiers on value types do not matter. */
87 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
88 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
90 if (inner_type
== outer_type
)
93 /* Changes in machine mode are never useless conversions because the RTL
94 middle-end expects explicit conversions between modes. */
95 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
))
98 /* If both the inner and outer types are integral types, then the
99 conversion is not necessary if they have the same mode and
100 signedness and precision, and both or neither are boolean. */
101 if (INTEGRAL_TYPE_P (inner_type
)
102 && INTEGRAL_TYPE_P (outer_type
))
104 /* Preserve changes in signedness or precision. */
105 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
106 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
109 /* Preserve conversions to/from BOOLEAN_TYPE if types are not
111 if (((TREE_CODE (inner_type
) == BOOLEAN_TYPE
)
112 != (TREE_CODE (outer_type
) == BOOLEAN_TYPE
))
113 && TYPE_PRECISION (outer_type
) != 1)
116 /* We don't need to preserve changes in the types minimum or
117 maximum value in general as these do not generate code
118 unless the types precisions are different. */
122 /* Scalar floating point types with the same mode are compatible. */
123 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
124 && SCALAR_FLOAT_TYPE_P (outer_type
))
127 /* Fixed point types with the same mode are compatible. */
128 else if (FIXED_POINT_TYPE_P (inner_type
)
129 && FIXED_POINT_TYPE_P (outer_type
))
130 return TYPE_SATURATING (inner_type
) == TYPE_SATURATING (outer_type
);
132 /* We need to take special care recursing to pointed-to types. */
133 else if (POINTER_TYPE_P (inner_type
)
134 && POINTER_TYPE_P (outer_type
))
136 /* We do not care for const qualification of the pointed-to types
137 as const qualification has no semantic value to the middle-end. */
139 /* Otherwise pointers/references are equivalent. */
143 /* Recurse for complex types. */
144 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
145 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
146 return useless_type_conversion_p (TREE_TYPE (outer_type
),
147 TREE_TYPE (inner_type
));
149 /* Recurse for vector types with the same number of subparts. */
150 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
151 && TREE_CODE (outer_type
) == VECTOR_TYPE
)
152 return (known_eq (TYPE_VECTOR_SUBPARTS (inner_type
),
153 TYPE_VECTOR_SUBPARTS (outer_type
))
154 && useless_type_conversion_p (TREE_TYPE (outer_type
),
155 TREE_TYPE (inner_type
))
156 && targetm
.compatible_vector_types_p (inner_type
, outer_type
));
158 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
159 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
161 /* Preserve various attributes. */
162 if (TYPE_REVERSE_STORAGE_ORDER (inner_type
)
163 != TYPE_REVERSE_STORAGE_ORDER (outer_type
))
165 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
168 /* Conversions from array types with unknown extent to
169 array types with known extent are not useless. */
170 if (!TYPE_DOMAIN (inner_type
) && TYPE_DOMAIN (outer_type
))
173 /* Nor are conversions from array types with non-constant size to
174 array types with constant size or to different size. */
175 if (TYPE_SIZE (outer_type
)
176 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
177 && (!TYPE_SIZE (inner_type
)
178 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
179 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
180 TYPE_SIZE (inner_type
))))
183 /* Check conversions between arrays with partially known extents.
184 If the array min/max values are constant they have to match.
185 Otherwise allow conversions to unknown and variable extents.
186 In particular this declares conversions that may change the
187 mode to BLKmode as useless. */
188 if (TYPE_DOMAIN (inner_type
)
189 && TYPE_DOMAIN (outer_type
)
190 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
192 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
193 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
194 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
195 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
197 /* After gimplification a variable min/max value carries no
198 additional information compared to a NULL value. All that
199 matters has been lowered to be part of the IL. */
200 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
201 inner_min
= NULL_TREE
;
202 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
203 outer_min
= NULL_TREE
;
204 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
205 inner_max
= NULL_TREE
;
206 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
207 outer_max
= NULL_TREE
;
209 /* Conversions NULL / variable <- cst are useless, but not
210 the other way around. */
213 || !tree_int_cst_equal (inner_min
, outer_min
)))
217 || !tree_int_cst_equal (inner_max
, outer_max
)))
221 /* Recurse on the element check. */
222 return useless_type_conversion_p (TREE_TYPE (outer_type
),
223 TREE_TYPE (inner_type
));
226 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
227 || TREE_CODE (inner_type
) == METHOD_TYPE
)
228 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
230 tree outer_parm
, inner_parm
;
232 /* If the return types are not compatible bail out. */
233 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
234 TREE_TYPE (inner_type
)))
237 /* Method types should belong to a compatible base class. */
238 if (TREE_CODE (inner_type
) == METHOD_TYPE
239 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
240 TYPE_METHOD_BASETYPE (inner_type
)))
243 /* A conversion to an unprototyped argument list is ok. */
244 if (!prototype_p (outer_type
))
247 /* If the unqualified argument types are compatible the conversion
249 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
252 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
253 inner_parm
= TYPE_ARG_TYPES (inner_type
);
254 outer_parm
&& inner_parm
;
255 outer_parm
= TREE_CHAIN (outer_parm
),
256 inner_parm
= TREE_CHAIN (inner_parm
))
257 if (!useless_type_conversion_p
258 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm
)),
259 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm
))))
262 /* If there is a mismatch in the number of arguments the functions
263 are not compatible. */
264 if (outer_parm
|| inner_parm
)
267 /* Defer to the target if necessary. */
268 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
269 return comp_type_attributes (outer_type
, inner_type
) != 0;
274 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
275 explicit conversions for types involving to be structurally
277 else if (AGGREGATE_TYPE_P (inner_type
)
278 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
279 return TYPE_CANONICAL (inner_type
)
280 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
);
282 else if (TREE_CODE (inner_type
) == OFFSET_TYPE
283 && TREE_CODE (outer_type
) == OFFSET_TYPE
)
284 return useless_type_conversion_p (TREE_TYPE (outer_type
),
285 TREE_TYPE (inner_type
))
286 && useless_type_conversion_p
287 (TYPE_OFFSET_BASETYPE (outer_type
),
288 TYPE_OFFSET_BASETYPE (inner_type
));
294 /* ----- Decl related ----- */
296 /* Set sequence SEQ to be the GIMPLE body for function FN. */
299 gimple_set_body (tree fndecl
, gimple_seq seq
)
301 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
304 /* If FNDECL still does not have a function structure associated
305 with it, then it does not make sense for it to receive a
307 gcc_assert (seq
== NULL
);
310 fn
->gimple_body
= seq
;
314 /* Return the body of GIMPLE statements for function FN. After the
315 CFG pass, the function body doesn't exist anymore because it has
316 been split up into basic blocks. In this case, it returns
320 gimple_body (tree fndecl
)
322 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
323 return fn
? fn
->gimple_body
: NULL
;
326 /* Return true when FNDECL has Gimple body either in unlowered
329 gimple_has_body_p (tree fndecl
)
331 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
332 return (gimple_body (fndecl
) || (fn
&& fn
->cfg
&& !(fn
->curr_properties
& PROP_rtl
)));
335 /* Return a printable name for symbol DECL. */
338 gimple_decl_printable_name (tree decl
, int verbosity
)
340 if (!DECL_NAME (decl
))
343 if (HAS_DECL_ASSEMBLER_NAME_P (decl
) && DECL_ASSEMBLER_NAME_SET_P (decl
))
345 int dmgl_opts
= DMGL_NO_OPTS
;
349 dmgl_opts
= DMGL_VERBOSE
353 if (TREE_CODE (decl
) == FUNCTION_DECL
)
354 dmgl_opts
|= DMGL_PARAMS
;
357 const char *mangled_str
358 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME_RAW (decl
));
359 const char *str
= cplus_demangle_v3 (mangled_str
, dmgl_opts
);
360 return str
? str
: mangled_str
;
363 return IDENTIFIER_POINTER (DECL_NAME (decl
));
367 /* Create a new VAR_DECL and copy information from VAR to it. */
370 copy_var_decl (tree var
, tree name
, tree type
)
372 tree copy
= build_decl (DECL_SOURCE_LOCATION (var
), VAR_DECL
, name
, type
);
374 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (var
);
375 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (var
);
376 DECL_NOT_GIMPLE_REG_P (copy
) = DECL_NOT_GIMPLE_REG_P (var
);
377 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (var
);
378 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (var
);
379 DECL_CONTEXT (copy
) = DECL_CONTEXT (var
);
380 TREE_USED (copy
) = 1;
381 DECL_SEEN_IN_BIND_EXPR_P (copy
) = 1;
382 DECL_ATTRIBUTES (copy
) = DECL_ATTRIBUTES (var
);
383 if (DECL_USER_ALIGN (var
))
385 SET_DECL_ALIGN (copy
, DECL_ALIGN (var
));
386 DECL_USER_ALIGN (copy
) = 1;
389 copy_warning (copy
, var
);
393 /* Strip off a legitimate source ending from the input string NAME of
394 length LEN. Rather than having to know the names used by all of
395 our front ends, we strip off an ending of a period followed by
396 up to four characters. (like ".cpp".) */
399 remove_suffix (char *name
, int len
)
403 for (i
= 2; i
< 7 && len
> i
; i
++)
405 if (name
[len
- i
] == '.')
407 name
[len
- i
] = '\0';
413 /* Create a new temporary name with PREFIX. Return an identifier. */
415 static GTY(()) unsigned int tmp_var_id_num
;
418 create_tmp_var_name (const char *prefix
)
424 char *preftmp
= ASTRDUP (prefix
);
426 remove_suffix (preftmp
, strlen (preftmp
));
427 clean_symbol_name (preftmp
);
432 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
? prefix
: "T", tmp_var_id_num
++);
433 return get_identifier (tmp_name
);
436 /* Create a new temporary variable declaration of type TYPE.
437 Do NOT push it into the current binding. */
440 create_tmp_var_raw (tree type
, const char *prefix
)
444 tmp_var
= build_decl (input_location
,
445 VAR_DECL
, prefix
? create_tmp_var_name (prefix
) : NULL
,
448 /* The variable was declared by the compiler. */
449 DECL_ARTIFICIAL (tmp_var
) = 1;
450 /* And we don't want debug info for it. */
451 DECL_IGNORED_P (tmp_var
) = 1;
452 /* And we don't want even the fancy names of those printed in
453 -fdump-final-insns= dumps. */
454 DECL_NAMELESS (tmp_var
) = 1;
456 /* Make the variable writable. */
457 TREE_READONLY (tmp_var
) = 0;
459 DECL_EXTERNAL (tmp_var
) = 0;
460 TREE_STATIC (tmp_var
) = 0;
461 TREE_USED (tmp_var
) = 1;
466 /* Create a new temporary variable declaration of type TYPE. DO push the
467 variable into the current binding. Further, assume that this is called
468 only from gimplification or optimization, at which point the creation of
469 certain types are bugs. */
472 create_tmp_var (tree type
, const char *prefix
)
476 /* We don't allow types that are addressable (meaning we can't make copies),
477 or incomplete. We also used to reject every variable size objects here,
478 but now support those for which a constant upper bound can be obtained.
479 The processing for variable sizes is performed in gimple_add_tmp_var,
480 point at which it really matters and possibly reached via paths not going
481 through this function, e.g. after direct calls to create_tmp_var_raw. */
482 gcc_assert (!TREE_ADDRESSABLE (type
) && COMPLETE_TYPE_P (type
));
484 tmp_var
= create_tmp_var_raw (type
, prefix
);
485 gimple_add_tmp_var (tmp_var
);
489 /* Create a new temporary variable declaration of type TYPE by calling
490 create_tmp_var and if TYPE is a vector or a complex number, mark the new
491 temporary as gimple register. */
494 create_tmp_reg (tree type
, const char *prefix
)
496 return create_tmp_var (type
, prefix
);
499 /* Create a new temporary variable declaration of type TYPE by calling
500 create_tmp_var and if TYPE is a vector or a complex number, mark the new
501 temporary as gimple register. */
504 create_tmp_reg_fn (struct function
*fn
, tree type
, const char *prefix
)
508 tmp
= create_tmp_var_raw (type
, prefix
);
509 gimple_add_tmp_var_fn (fn
, tmp
);
515 /* ----- Expression related ----- */
517 /* Extract the operands and code for expression EXPR into *SUBCODE_P,
518 *OP1_P, *OP2_P and *OP3_P respectively. */
521 extract_ops_from_tree (tree expr
, enum tree_code
*subcode_p
, tree
*op1_p
,
522 tree
*op2_p
, tree
*op3_p
)
524 *subcode_p
= TREE_CODE (expr
);
525 switch (get_gimple_rhs_class (*subcode_p
))
527 case GIMPLE_TERNARY_RHS
:
529 *op1_p
= TREE_OPERAND (expr
, 0);
530 *op2_p
= TREE_OPERAND (expr
, 1);
531 *op3_p
= TREE_OPERAND (expr
, 2);
534 case GIMPLE_BINARY_RHS
:
536 *op1_p
= TREE_OPERAND (expr
, 0);
537 *op2_p
= TREE_OPERAND (expr
, 1);
541 case GIMPLE_UNARY_RHS
:
543 *op1_p
= TREE_OPERAND (expr
, 0);
548 case GIMPLE_SINGLE_RHS
:
560 /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */
563 gimple_cond_get_ops_from_tree (tree cond
, enum tree_code
*code_p
,
564 tree
*lhs_p
, tree
*rhs_p
)
566 gcc_assert (COMPARISON_CLASS_P (cond
)
567 || TREE_CODE (cond
) == TRUTH_NOT_EXPR
568 || is_gimple_min_invariant (cond
)
569 || SSA_VAR_P (cond
));
570 gcc_checking_assert (!tree_could_throw_p (cond
));
572 extract_ops_from_tree (cond
, code_p
, lhs_p
, rhs_p
);
574 /* Canonicalize conditionals of the form 'if (!VAL)'. */
575 if (*code_p
== TRUTH_NOT_EXPR
)
578 gcc_assert (*lhs_p
&& *rhs_p
== NULL_TREE
);
579 *rhs_p
= build_zero_cst (TREE_TYPE (*lhs_p
));
581 /* Canonicalize conditionals of the form 'if (VAL)' */
582 else if (TREE_CODE_CLASS (*code_p
) != tcc_comparison
)
585 gcc_assert (*lhs_p
&& *rhs_p
== NULL_TREE
);
586 *rhs_p
= build_zero_cst (TREE_TYPE (*lhs_p
));
590 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
593 is_gimple_lvalue (tree t
)
595 return (is_gimple_addressable (t
)
596 || TREE_CODE (t
) == WITH_SIZE_EXPR
597 /* These are complex lvalues, but don't have addresses, so they
599 || TREE_CODE (t
) == BIT_FIELD_REF
);
602 /* Helper for is_gimple_condexpr and is_gimple_condexpr_for_cond. */
605 is_gimple_condexpr_1 (tree t
, bool allow_traps
, bool allow_cplx
)
608 return (is_gimple_val (t
)
609 || (COMPARISON_CLASS_P (t
)
610 && (allow_traps
|| !tree_could_throw_p (t
))
611 && ((op0
= TREE_OPERAND (t
, 0)), true)
612 && (allow_cplx
|| TREE_CODE (TREE_TYPE (op0
)) != COMPLEX_TYPE
)
613 && is_gimple_val (op0
)
614 && is_gimple_val (TREE_OPERAND (t
, 1))));
617 /* Return true if T is a condition operand in a GIMPLE assignment
618 with a COND_EXPR RHS. */
621 is_gimple_condexpr (tree t
)
623 /* Always split out _Complex type compares since complex lowering
624 doesn't handle this case. */
625 return is_gimple_condexpr_1 (t
, true, false);
628 /* Like is_gimple_condexpr, but does not allow T to trap. */
631 is_gimple_condexpr_for_cond (tree t
)
633 return is_gimple_condexpr_1 (t
, false, true);
636 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
637 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
638 we failed to create one. */
641 canonicalize_cond_expr_cond (tree t
)
643 /* Strip conversions around boolean operations. */
644 if (CONVERT_EXPR_P (t
)
645 && (truth_value_p (TREE_CODE (TREE_OPERAND (t
, 0)))
646 || TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
648 t
= TREE_OPERAND (t
, 0);
650 /* For !x use x == 0. */
651 if (TREE_CODE (t
) == TRUTH_NOT_EXPR
)
653 tree top0
= TREE_OPERAND (t
, 0);
654 t
= build2 (EQ_EXPR
, TREE_TYPE (t
),
655 top0
, build_int_cst (TREE_TYPE (top0
), 0));
657 /* For cmp ? 1 : 0 use cmp. */
658 else if (TREE_CODE (t
) == COND_EXPR
659 && COMPARISON_CLASS_P (TREE_OPERAND (t
, 0))
660 && integer_onep (TREE_OPERAND (t
, 1))
661 && integer_zerop (TREE_OPERAND (t
, 2)))
663 tree top0
= TREE_OPERAND (t
, 0);
664 t
= build2 (TREE_CODE (top0
), TREE_TYPE (t
),
665 TREE_OPERAND (top0
, 0), TREE_OPERAND (top0
, 1));
667 /* For x ^ y use x != y. */
668 else if (TREE_CODE (t
) == BIT_XOR_EXPR
)
669 t
= build2 (NE_EXPR
, TREE_TYPE (t
),
670 TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1));
672 /* We don't know where this will be used so allow both traps and
673 _Complex. The caller is responsible for more precise checking. */
674 if (is_gimple_condexpr_1 (t
, true, true))
680 /* Return true if T is a gimple address. */
683 is_gimple_address (const_tree t
)
687 if (TREE_CODE (t
) != ADDR_EXPR
)
690 op
= TREE_OPERAND (t
, 0);
691 while (handled_component_p (op
))
693 if ((TREE_CODE (op
) == ARRAY_REF
694 || TREE_CODE (op
) == ARRAY_RANGE_REF
)
695 && !is_gimple_val (TREE_OPERAND (op
, 1)))
698 op
= TREE_OPERAND (op
, 0);
701 if (CONSTANT_CLASS_P (op
)
702 || TREE_CODE (op
) == TARGET_MEM_REF
703 || TREE_CODE (op
) == MEM_REF
)
706 switch (TREE_CODE (op
))
721 /* Return true if T is a gimple invariant address. */
724 is_gimple_invariant_address (const_tree t
)
728 if (TREE_CODE (t
) != ADDR_EXPR
)
731 op
= strip_invariant_refs (TREE_OPERAND (t
, 0));
735 if (TREE_CODE (op
) == MEM_REF
)
737 const_tree op0
= TREE_OPERAND (op
, 0);
738 return (TREE_CODE (op0
) == ADDR_EXPR
739 && (CONSTANT_CLASS_P (TREE_OPERAND (op0
, 0))
740 || decl_address_invariant_p (TREE_OPERAND (op0
, 0))));
743 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
746 /* Return true if T is a gimple invariant address at IPA level
747 (so addresses of variables on stack are not allowed). */
750 is_gimple_ip_invariant_address (const_tree t
)
754 if (TREE_CODE (t
) != ADDR_EXPR
)
757 op
= strip_invariant_refs (TREE_OPERAND (t
, 0));
761 if (TREE_CODE (op
) == MEM_REF
)
763 const_tree op0
= TREE_OPERAND (op
, 0);
764 return (TREE_CODE (op0
) == ADDR_EXPR
765 && (CONSTANT_CLASS_P (TREE_OPERAND (op0
, 0))
766 || decl_address_ip_invariant_p (TREE_OPERAND (op0
, 0))));
769 return CONSTANT_CLASS_P (op
) || decl_address_ip_invariant_p (op
);
772 /* Return true if T is a GIMPLE minimal invariant. It's a restricted
773 form of function invariant. */
776 is_gimple_min_invariant (const_tree t
)
778 if (TREE_CODE (t
) == ADDR_EXPR
)
779 return is_gimple_invariant_address (t
);
781 return is_gimple_constant (t
);
784 /* Return true if T is a GIMPLE interprocedural invariant. It's a restricted
785 form of gimple minimal invariant. */
788 is_gimple_ip_invariant (const_tree t
)
790 if (TREE_CODE (t
) == ADDR_EXPR
)
791 return is_gimple_ip_invariant_address (t
);
793 return is_gimple_constant (t
);
796 /* Return true if T is a non-aggregate register variable. */
799 is_gimple_reg (tree t
)
801 if (virtual_operand_p (t
))
804 if (TREE_CODE (t
) == SSA_NAME
)
807 if (!is_gimple_variable (t
))
810 if (!is_gimple_reg_type (TREE_TYPE (t
)))
813 /* A volatile decl is not acceptable because we can't reuse it as
814 needed. We need to copy it into a temp first. */
815 if (TREE_THIS_VOLATILE (t
))
818 /* We define "registers" as things that can be renamed as needed,
819 which with our infrastructure does not apply to memory. */
820 if (needs_to_live_in_memory (t
))
823 /* Hard register variables are an interesting case. For those that
824 are call-clobbered, we don't know where all the calls are, since
825 we don't (want to) take into account which operations will turn
826 into libcalls at the rtl level. For those that are call-saved,
827 we don't currently model the fact that calls may in fact change
828 global hard registers, nor do we examine ASM_CLOBBERS at the tree
829 level, and so miss variable changes that might imply. All around,
830 it seems safest to not do too much optimization with these at the
831 tree level at all. We'll have to rely on the rtl optimizers to
832 clean this up, as there we've got all the appropriate bits exposed. */
833 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
836 /* Variables can be marked as having partial definitions, avoid
837 putting them into SSA form. */
838 return !DECL_NOT_GIMPLE_REG_P (t
);
842 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
845 is_gimple_val (tree t
)
847 /* Make loads from volatiles and memory vars explicit. */
848 if (is_gimple_variable (t
)
849 && is_gimple_reg_type (TREE_TYPE (t
))
850 && !is_gimple_reg (t
))
853 return (is_gimple_variable (t
) || is_gimple_min_invariant (t
));
856 /* Similarly, but accept hard registers as inputs to asm statements. */
859 is_gimple_asm_val (tree t
)
861 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
864 return is_gimple_val (t
);
867 /* Return true if T is a GIMPLE minimal lvalue. */
870 is_gimple_min_lval (tree t
)
872 if (!(t
= CONST_CAST_TREE (strip_invariant_refs (t
))))
874 return (is_gimple_id (t
) || TREE_CODE (t
) == MEM_REF
);
877 /* Return true if T is a valid function operand of a CALL_EXPR. */
880 is_gimple_call_addr (tree t
)
882 return (TREE_CODE (t
) == OBJ_TYPE_REF
|| is_gimple_val (t
));
885 /* Return true if T is a valid address operand of a MEM_REF. */
888 is_gimple_mem_ref_addr (tree t
)
890 return (is_gimple_reg (t
)
891 || TREE_CODE (t
) == INTEGER_CST
892 || (TREE_CODE (t
) == ADDR_EXPR
893 && (CONSTANT_CLASS_P (TREE_OPERAND (t
, 0))
894 || decl_address_invariant_p (TREE_OPERAND (t
, 0)))));
897 /* Hold trees marked addressable during expand. */
899 static hash_set
<tree
> *mark_addressable_queue
;
901 /* Mark X as addressable or queue it up if called during expand. We
902 don't want to apply it immediately during expand because decls are
903 made addressable at that point due to RTL-only concerns, such as
904 uses of memcpy for block moves, and TREE_ADDRESSABLE changes
905 is_gimple_reg, which might make it seem like a variable that used
906 to be a gimple_reg shouldn't have been an SSA name. So we queue up
907 this flag setting and only apply it when we're done with GIMPLE and
908 only RTL issues matter. */
911 mark_addressable_1 (tree x
)
913 if (!currently_expanding_to_rtl
)
915 TREE_ADDRESSABLE (x
) = 1;
919 if (!mark_addressable_queue
)
920 mark_addressable_queue
= new hash_set
<tree
>();
921 mark_addressable_queue
->add (x
);
924 /* Adaptor for mark_addressable_1 for use in hash_set traversal. */
927 mark_addressable_2 (tree
const &x
, void * ATTRIBUTE_UNUSED
= NULL
)
929 mark_addressable_1 (x
);
933 /* Mark all queued trees as addressable, and empty the queue. To be
934 called right after clearing CURRENTLY_EXPANDING_TO_RTL. */
937 flush_mark_addressable_queue ()
939 gcc_assert (!currently_expanding_to_rtl
);
940 if (mark_addressable_queue
)
942 mark_addressable_queue
->traverse
<void*, mark_addressable_2
> (NULL
);
943 delete mark_addressable_queue
;
944 mark_addressable_queue
= NULL
;
948 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
949 form and we don't do any syntax checking. */
952 mark_addressable (tree x
)
954 if (TREE_CODE (x
) == WITH_SIZE_EXPR
)
955 x
= TREE_OPERAND (x
, 0);
956 while (handled_component_p (x
))
957 x
= TREE_OPERAND (x
, 0);
958 if ((TREE_CODE (x
) == MEM_REF
959 || TREE_CODE (x
) == TARGET_MEM_REF
)
960 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
961 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
963 && TREE_CODE (x
) != PARM_DECL
964 && TREE_CODE (x
) != RESULT_DECL
)
966 mark_addressable_1 (x
);
968 /* Also mark the artificial SSA_NAME that points to the partition of X. */
969 if (TREE_CODE (x
) == VAR_DECL
970 && !DECL_EXTERNAL (x
)
972 && cfun
->gimple_df
!= NULL
973 && cfun
->gimple_df
->decls_to_pointers
!= NULL
)
975 tree
*namep
= cfun
->gimple_df
->decls_to_pointers
->get (x
);
977 mark_addressable_1 (*namep
);
981 /* Returns true iff T is a valid RHS for an assignment to a renamed
982 user -- or front-end generated artificial -- variable. */
985 is_gimple_reg_rhs (tree t
)
987 return get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
;
990 #include "gt-gimple-expr.h"