1 /* Gimple decl, type, and expression support functions.
3 Copyright (C) 2007-2015 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"
29 #include "double-int.h"
36 #include "fold-const.h"
38 #include "hard-reg-set.h"
41 #include "basic-block.h"
42 #include "tree-ssa-alias.h"
43 #include "internal-fn.h"
45 #include "gimple-expr.h"
48 #include "stringpool.h"
50 #include "stor-layout.h"
52 #include "gimple-ssa.h"
54 /* ----- Type related ----- */
56 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
57 useless type conversion, otherwise return false.
59 This function implicitly defines the middle-end type system. With
60 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
61 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
62 the following invariants shall be fulfilled:
64 1) useless_type_conversion_p is transitive.
65 If a < b and b < c then a < c.
67 2) useless_type_conversion_p is not symmetric.
68 From a < b does not follow a > b.
70 3) Types define the available set of operations applicable to values.
71 A type conversion is useless if the operations for the target type
72 is a subset of the operations for the source type. For example
73 casts to void* are useless, casts from void* are not (void* can't
74 be dereferenced or offsetted, but copied, hence its set of operations
75 is a strict subset of that of all other data pointer types). Casts
76 to const T* are useless (can't be written to), casts from const T*
80 useless_type_conversion_p (tree outer_type, tree inner_type)
82 /* Do the following before stripping toplevel qualifiers. */
83 if (POINTER_TYPE_P (inner_type)
84 && POINTER_TYPE_P (outer_type))
86 /* Do not lose casts between pointers to different address spaces. */
87 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
88 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type)))
92 /* From now on qualifiers on value types do not matter. */
93 inner_type = TYPE_MAIN_VARIANT (inner_type);
94 outer_type = TYPE_MAIN_VARIANT (outer_type);
96 if (inner_type == outer_type)
99 /* If we know the canonical types, compare them. */
100 if (TYPE_CANONICAL (inner_type)
101 && TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type))
104 /* Changes in machine mode are never useless conversions unless we
105 deal with aggregate types in which case we defer to later checks. */
106 if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type)
107 && !AGGREGATE_TYPE_P (inner_type))
110 /* If both the inner and outer types are integral types, then the
111 conversion is not necessary if they have the same mode and
112 signedness and precision, and both or neither are boolean. */
113 if (INTEGRAL_TYPE_P (inner_type)
114 && INTEGRAL_TYPE_P (outer_type))
116 /* Preserve changes in signedness or precision. */
117 if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
118 || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
121 /* Preserve conversions to/from BOOLEAN_TYPE if types are not
123 if (((TREE_CODE (inner_type) == BOOLEAN_TYPE)
124 != (TREE_CODE (outer_type) == BOOLEAN_TYPE))
125 && TYPE_PRECISION (outer_type) != 1)
128 /* We don't need to preserve changes in the types minimum or
129 maximum value in general as these do not generate code
130 unless the types precisions are different. */
134 /* Scalar floating point types with the same mode are compatible. */
135 else if (SCALAR_FLOAT_TYPE_P (inner_type)
136 && SCALAR_FLOAT_TYPE_P (outer_type))
139 /* Fixed point types with the same mode are compatible. */
140 else if (FIXED_POINT_TYPE_P (inner_type)
141 && FIXED_POINT_TYPE_P (outer_type))
144 /* We need to take special care recursing to pointed-to types. */
145 else if (POINTER_TYPE_P (inner_type)
146 && POINTER_TYPE_P (outer_type))
148 /* Do not lose casts to function pointer types. */
149 if ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
150 || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
151 && !(TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE
152 || TREE_CODE (TREE_TYPE (inner_type)) == METHOD_TYPE))
155 /* We do not care for const qualification of the pointed-to types
156 as const qualification has no semantic value to the middle-end. */
158 /* Otherwise pointers/references are equivalent. */
162 /* Recurse for complex types. */
163 else if (TREE_CODE (inner_type) == COMPLEX_TYPE
164 && TREE_CODE (outer_type) == COMPLEX_TYPE)
165 return useless_type_conversion_p (TREE_TYPE (outer_type),
166 TREE_TYPE (inner_type));
168 /* Recurse for vector types with the same number of subparts. */
169 else if (TREE_CODE (inner_type) == VECTOR_TYPE
170 && TREE_CODE (outer_type) == VECTOR_TYPE
171 && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
172 return useless_type_conversion_p (TREE_TYPE (outer_type),
173 TREE_TYPE (inner_type));
175 else if (TREE_CODE (inner_type) == ARRAY_TYPE
176 && TREE_CODE (outer_type) == ARRAY_TYPE)
178 /* Preserve string attributes. */
179 if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type))
182 /* Conversions from array types with unknown extent to
183 array types with known extent are not useless. */
184 if (!TYPE_DOMAIN (inner_type)
185 && TYPE_DOMAIN (outer_type))
188 /* Nor are conversions from array types with non-constant size to
189 array types with constant size or to different size. */
190 if (TYPE_SIZE (outer_type)
191 && TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST
192 && (!TYPE_SIZE (inner_type)
193 || TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST
194 || !tree_int_cst_equal (TYPE_SIZE (outer_type),
195 TYPE_SIZE (inner_type))))
198 /* Check conversions between arrays with partially known extents.
199 If the array min/max values are constant they have to match.
200 Otherwise allow conversions to unknown and variable extents.
201 In particular this declares conversions that may change the
202 mode to BLKmode as useless. */
203 if (TYPE_DOMAIN (inner_type)
204 && TYPE_DOMAIN (outer_type)
205 && TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type))
207 tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type));
208 tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type));
209 tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type));
210 tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type));
212 /* After gimplification a variable min/max value carries no
213 additional information compared to a NULL value. All that
214 matters has been lowered to be part of the IL. */
215 if (inner_min && TREE_CODE (inner_min) != INTEGER_CST)
216 inner_min = NULL_TREE;
217 if (outer_min && TREE_CODE (outer_min) != INTEGER_CST)
218 outer_min = NULL_TREE;
219 if (inner_max && TREE_CODE (inner_max) != INTEGER_CST)
220 inner_max = NULL_TREE;
221 if (outer_max && TREE_CODE (outer_max) != INTEGER_CST)
222 outer_max = NULL_TREE;
224 /* Conversions NULL / variable <- cst are useless, but not
225 the other way around. */
228 || !tree_int_cst_equal (inner_min, outer_min)))
232 || !tree_int_cst_equal (inner_max, outer_max)))
236 /* Recurse on the element check. */
237 return useless_type_conversion_p (TREE_TYPE (outer_type),
238 TREE_TYPE (inner_type));
241 else if ((TREE_CODE (inner_type) == FUNCTION_TYPE
242 || TREE_CODE (inner_type) == METHOD_TYPE)
243 && TREE_CODE (inner_type) == TREE_CODE (outer_type))
245 tree outer_parm, inner_parm;
247 /* If the return types are not compatible bail out. */
248 if (!useless_type_conversion_p (TREE_TYPE (outer_type),
249 TREE_TYPE (inner_type)))
252 /* Method types should belong to a compatible base class. */
253 if (TREE_CODE (inner_type) == METHOD_TYPE
254 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type),
255 TYPE_METHOD_BASETYPE (inner_type)))
258 /* A conversion to an unprototyped argument list is ok. */
259 if (!prototype_p (outer_type))
262 /* If the unqualified argument types are compatible the conversion
264 if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type))
267 for (outer_parm = TYPE_ARG_TYPES (outer_type),
268 inner_parm = TYPE_ARG_TYPES (inner_type);
269 outer_parm && inner_parm;
270 outer_parm = TREE_CHAIN (outer_parm),
271 inner_parm = TREE_CHAIN (inner_parm))
272 if (!useless_type_conversion_p
273 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm)),
274 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm))))
277 /* If there is a mismatch in the number of arguments the functions
278 are not compatible. */
279 if (outer_parm || inner_parm)
282 /* Defer to the target if necessary. */
283 if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type))
284 return comp_type_attributes (outer_type, inner_type) != 0;
289 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
290 explicit conversions for types involving to be structurally
292 else if (AGGREGATE_TYPE_P (inner_type)
293 && TREE_CODE (inner_type) == TREE_CODE (outer_type))
300 /* ----- Decl related ----- */
302 /* Set sequence SEQ to be the GIMPLE body for function FN. */
305 gimple_set_body (tree fndecl, gimple_seq seq)
307 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
310 /* If FNDECL still does not have a function structure associated
311 with it, then it does not make sense for it to receive a
313 gcc_assert (seq == NULL);
316 fn->gimple_body = seq;
320 /* Return the body of GIMPLE statements for function FN. After the
321 CFG pass, the function body doesn't exist anymore because it has
322 been split up into basic blocks. In this case, it returns
326 gimple_body (tree fndecl)
328 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
329 return fn ? fn->gimple_body : NULL;
332 /* Return true when FNDECL has Gimple body either in unlowered
335 gimple_has_body_p (tree fndecl)
337 struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
338 return (gimple_body (fndecl) || (fn && fn->cfg));
341 /* Return a printable name for symbol DECL. */
344 gimple_decl_printable_name (tree decl, int verbosity)
346 if (!DECL_NAME (decl))
349 if (DECL_ASSEMBLER_NAME_SET_P (decl))
351 const char *str, *mangled_str;
352 int dmgl_opts = DMGL_NO_OPTS;
356 dmgl_opts = DMGL_VERBOSE
360 if (TREE_CODE (decl) == FUNCTION_DECL)
361 dmgl_opts |= DMGL_PARAMS;
364 mangled_str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
365 str = cplus_demangle_v3 (mangled_str, dmgl_opts);
366 return (str) ? str : mangled_str;
369 return IDENTIFIER_POINTER (DECL_NAME (decl));
373 /* Create a new VAR_DECL and copy information from VAR to it. */
376 copy_var_decl (tree var, tree name, tree type)
378 tree copy = build_decl (DECL_SOURCE_LOCATION (var), VAR_DECL, name, type);
380 TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (var);
381 TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (var);
382 DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (var);
383 DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (var);
384 DECL_IGNORED_P (copy) = DECL_IGNORED_P (var);
385 DECL_CONTEXT (copy) = DECL_CONTEXT (var);
386 TREE_NO_WARNING (copy) = TREE_NO_WARNING (var);
387 TREE_USED (copy) = 1;
388 DECL_SEEN_IN_BIND_EXPR_P (copy) = 1;
389 DECL_ATTRIBUTES (copy) = DECL_ATTRIBUTES (var);
390 if (DECL_USER_ALIGN (var))
392 DECL_ALIGN (copy) = DECL_ALIGN (var);
393 DECL_USER_ALIGN (copy) = 1;
399 /* Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for
400 coalescing together, false otherwise.
402 This must stay consistent with var_map_base_init in tree-ssa-live.c. */
405 gimple_can_coalesce_p (tree name1, tree name2)
407 /* First check the SSA_NAME's associated DECL. We only want to
408 coalesce if they have the same DECL or both have no associated DECL. */
409 tree var1 = SSA_NAME_VAR (name1);
410 tree var2 = SSA_NAME_VAR (name2);
411 var1 = (var1 && (!VAR_P (var1) || !DECL_IGNORED_P (var1))) ? var1 : NULL_TREE;
412 var2 = (var2 && (!VAR_P (var2) || !DECL_IGNORED_P (var2))) ? var2 : NULL_TREE;
416 /* Now check the types. If the types are the same, then we should
417 try to coalesce V1 and V2. */
418 tree t1 = TREE_TYPE (name1);
419 tree t2 = TREE_TYPE (name2);
423 /* If the types are not the same, check for a canonical type match. This
424 (for example) allows coalescing when the types are fundamentally the
425 same, but just have different names.
427 Note pointer types with different address spaces may have the same
428 canonical type. Those are rejected for coalescing by the
429 types_compatible_p check. */
430 if (TYPE_CANONICAL (t1)
431 && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2)
432 && types_compatible_p (t1, t2))
438 /* Strip off a legitimate source ending from the input string NAME of
439 length LEN. Rather than having to know the names used by all of
440 our front ends, we strip off an ending of a period followed by
441 up to five characters. (Java uses ".class".) */
444 remove_suffix (char *name, int len)
448 for (i = 2; i < 8 && len > i; i++)
450 if (name[len - i] == '.')
452 name[len - i] = '\0';
458 /* Create a new temporary name with PREFIX. Return an identifier. */
460 static GTY(()) unsigned int tmp_var_id_num;
463 create_tmp_var_name (const char *prefix)
469 char *preftmp = ASTRDUP (prefix);
471 remove_suffix (preftmp, strlen (preftmp));
472 clean_symbol_name (preftmp);
477 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
478 return get_identifier (tmp_name);
481 /* Create a new temporary variable declaration of type TYPE.
482 Do NOT push it into the current binding. */
485 create_tmp_var_raw (tree type, const char *prefix)
489 tmp_var = build_decl (input_location,
490 VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
493 /* The variable was declared by the compiler. */
494 DECL_ARTIFICIAL (tmp_var) = 1;
495 /* And we don't want debug info for it. */
496 DECL_IGNORED_P (tmp_var) = 1;
498 /* Make the variable writable. */
499 TREE_READONLY (tmp_var) = 0;
501 DECL_EXTERNAL (tmp_var) = 0;
502 TREE_STATIC (tmp_var) = 0;
503 TREE_USED (tmp_var) = 1;
508 /* Create a new temporary variable declaration of type TYPE. DO push the
509 variable into the current binding. Further, assume that this is called
510 only from gimplification or optimization, at which point the creation of
511 certain types are bugs. */
514 create_tmp_var (tree type, const char *prefix)
518 /* We don't allow types that are addressable (meaning we can't make copies),
519 or incomplete. We also used to reject every variable size objects here,
520 but now support those for which a constant upper bound can be obtained.
521 The processing for variable sizes is performed in gimple_add_tmp_var,
522 point at which it really matters and possibly reached via paths not going
523 through this function, e.g. after direct calls to create_tmp_var_raw. */
524 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
526 tmp_var = create_tmp_var_raw (type, prefix);
527 gimple_add_tmp_var (tmp_var);
531 /* Create a new temporary variable declaration of type TYPE by calling
532 create_tmp_var and if TYPE is a vector or a complex number, mark the new
533 temporary as gimple register. */
536 create_tmp_reg (tree type, const char *prefix)
540 tmp = create_tmp_var (type, prefix);
541 if (TREE_CODE (type) == COMPLEX_TYPE
542 || TREE_CODE (type) == VECTOR_TYPE)
543 DECL_GIMPLE_REG_P (tmp) = 1;
548 /* Create a new temporary variable declaration of type TYPE by calling
549 create_tmp_var and if TYPE is a vector or a complex number, mark the new
550 temporary as gimple register. */
553 create_tmp_reg_fn (struct function *fn, tree type, const char *prefix)
557 tmp = create_tmp_var_raw (type, prefix);
558 gimple_add_tmp_var_fn (fn, tmp);
559 if (TREE_CODE (type) == COMPLEX_TYPE
560 || TREE_CODE (type) == VECTOR_TYPE)
561 DECL_GIMPLE_REG_P (tmp) = 1;
567 /* ----- Expression related ----- */
569 /* Extract the operands and code for expression EXPR into *SUBCODE_P,
570 *OP1_P, *OP2_P and *OP3_P respectively. */
573 extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
574 tree *op2_p, tree *op3_p)
576 enum gimple_rhs_class grhs_class;
578 *subcode_p = TREE_CODE (expr);
579 grhs_class = get_gimple_rhs_class (*subcode_p);
581 if (grhs_class == GIMPLE_TERNARY_RHS)
583 *op1_p = TREE_OPERAND (expr, 0);
584 *op2_p = TREE_OPERAND (expr, 1);
585 *op3_p = TREE_OPERAND (expr, 2);
587 else if (grhs_class == GIMPLE_BINARY_RHS)
589 *op1_p = TREE_OPERAND (expr, 0);
590 *op2_p = TREE_OPERAND (expr, 1);
593 else if (grhs_class == GIMPLE_UNARY_RHS)
595 *op1_p = TREE_OPERAND (expr, 0);
599 else if (grhs_class == GIMPLE_SINGLE_RHS)
609 /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */
612 gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
613 tree *lhs_p, tree *rhs_p)
615 gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison
616 || TREE_CODE (cond) == TRUTH_NOT_EXPR
617 || is_gimple_min_invariant (cond)
618 || SSA_VAR_P (cond));
620 extract_ops_from_tree (cond, code_p, lhs_p, rhs_p);
622 /* Canonicalize conditionals of the form 'if (!VAL)'. */
623 if (*code_p == TRUTH_NOT_EXPR)
626 gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
627 *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
629 /* Canonicalize conditionals of the form 'if (VAL)' */
630 else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
633 gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
634 *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
638 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
641 is_gimple_lvalue (tree t)
643 return (is_gimple_addressable (t)
644 || TREE_CODE (t) == WITH_SIZE_EXPR
645 /* These are complex lvalues, but don't have addresses, so they
647 || TREE_CODE (t) == BIT_FIELD_REF);
650 /* Return true if T is a GIMPLE condition. */
653 is_gimple_condexpr (tree t)
655 return (is_gimple_val (t) || (COMPARISON_CLASS_P (t)
656 && !tree_could_throw_p (t)
657 && is_gimple_val (TREE_OPERAND (t, 0))
658 && is_gimple_val (TREE_OPERAND (t, 1))));
661 /* Return true if T is a gimple address. */
664 is_gimple_address (const_tree t)
668 if (TREE_CODE (t) != ADDR_EXPR)
671 op = TREE_OPERAND (t, 0);
672 while (handled_component_p (op))
674 if ((TREE_CODE (op) == ARRAY_REF
675 || TREE_CODE (op) == ARRAY_RANGE_REF)
676 && !is_gimple_val (TREE_OPERAND (op, 1)))
679 op = TREE_OPERAND (op, 0);
682 if (CONSTANT_CLASS_P (op) || TREE_CODE (op) == MEM_REF)
685 switch (TREE_CODE (op))
700 /* Return true if T is a gimple invariant address. */
703 is_gimple_invariant_address (const_tree t)
707 if (TREE_CODE (t) != ADDR_EXPR)
710 op = strip_invariant_refs (TREE_OPERAND (t, 0));
714 if (TREE_CODE (op) == MEM_REF)
716 const_tree op0 = TREE_OPERAND (op, 0);
717 return (TREE_CODE (op0) == ADDR_EXPR
718 && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
719 || decl_address_invariant_p (TREE_OPERAND (op0, 0))));
722 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
725 /* Return true if T is a gimple invariant address at IPA level
726 (so addresses of variables on stack are not allowed). */
729 is_gimple_ip_invariant_address (const_tree t)
733 if (TREE_CODE (t) != ADDR_EXPR)
736 op = strip_invariant_refs (TREE_OPERAND (t, 0));
740 if (TREE_CODE (op) == MEM_REF)
742 const_tree op0 = TREE_OPERAND (op, 0);
743 return (TREE_CODE (op0) == ADDR_EXPR
744 && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
745 || decl_address_ip_invariant_p (TREE_OPERAND (op0, 0))));
748 return CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op);
751 /* Return true if T is a GIMPLE minimal invariant. It's a restricted
752 form of function invariant. */
755 is_gimple_min_invariant (const_tree t)
757 if (TREE_CODE (t) == ADDR_EXPR)
758 return is_gimple_invariant_address (t);
760 return is_gimple_constant (t);
763 /* Return true if T is a GIMPLE interprocedural invariant. It's a restricted
764 form of gimple minimal invariant. */
767 is_gimple_ip_invariant (const_tree t)
769 if (TREE_CODE (t) == ADDR_EXPR)
770 return is_gimple_ip_invariant_address (t);
772 return is_gimple_constant (t);
775 /* Return true if T is a non-aggregate register variable. */
778 is_gimple_reg (tree t)
780 if (virtual_operand_p (t))
783 if (TREE_CODE (t) == SSA_NAME)
786 if (!is_gimple_variable (t))
789 if (!is_gimple_reg_type (TREE_TYPE (t)))
792 /* A volatile decl is not acceptable because we can't reuse it as
793 needed. We need to copy it into a temp first. */
794 if (TREE_THIS_VOLATILE (t))
797 /* We define "registers" as things that can be renamed as needed,
798 which with our infrastructure does not apply to memory. */
799 if (needs_to_live_in_memory (t))
802 /* Hard register variables are an interesting case. For those that
803 are call-clobbered, we don't know where all the calls are, since
804 we don't (want to) take into account which operations will turn
805 into libcalls at the rtl level. For those that are call-saved,
806 we don't currently model the fact that calls may in fact change
807 global hard registers, nor do we examine ASM_CLOBBERS at the tree
808 level, and so miss variable changes that might imply. All around,
809 it seems safest to not do too much optimization with these at the
810 tree level at all. We'll have to rely on the rtl optimizers to
811 clean this up, as there we've got all the appropriate bits exposed. */
812 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
815 /* Complex and vector values must have been put into SSA-like form.
816 That is, no assignments to the individual components. */
817 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
818 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
819 return DECL_GIMPLE_REG_P (t);
825 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
828 is_gimple_val (tree t)
830 /* Make loads from volatiles and memory vars explicit. */
831 if (is_gimple_variable (t)
832 && is_gimple_reg_type (TREE_TYPE (t))
833 && !is_gimple_reg (t))
836 return (is_gimple_variable (t) || is_gimple_min_invariant (t));
839 /* Similarly, but accept hard registers as inputs to asm statements. */
842 is_gimple_asm_val (tree t)
844 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
847 return is_gimple_val (t);
850 /* Return true if T is a GIMPLE minimal lvalue. */
853 is_gimple_min_lval (tree t)
855 if (!(t = CONST_CAST_TREE (strip_invariant_refs (t))))
857 return (is_gimple_id (t) || TREE_CODE (t) == MEM_REF);
860 /* Return true if T is a valid function operand of a CALL_EXPR. */
863 is_gimple_call_addr (tree t)
865 return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
868 /* Return true if T is a valid address operand of a MEM_REF. */
871 is_gimple_mem_ref_addr (tree t)
873 return (is_gimple_reg (t)
874 || TREE_CODE (t) == INTEGER_CST
875 || (TREE_CODE (t) == ADDR_EXPR
876 && (CONSTANT_CLASS_P (TREE_OPERAND (t, 0))
877 || decl_address_invariant_p (TREE_OPERAND (t, 0)))));
880 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
881 form and we don't do any syntax checking. */
884 mark_addressable (tree x)
886 while (handled_component_p (x))
887 x = TREE_OPERAND (x, 0);
888 if (TREE_CODE (x) == MEM_REF
889 && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
890 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
891 if (TREE_CODE (x) != VAR_DECL
892 && TREE_CODE (x) != PARM_DECL
893 && TREE_CODE (x) != RESULT_DECL)
895 TREE_ADDRESSABLE (x) = 1;
897 /* Also mark the artificial SSA_NAME that points to the partition of X. */
898 if (TREE_CODE (x) == VAR_DECL
899 && !DECL_EXTERNAL (x)
901 && cfun->gimple_df != NULL
902 && cfun->gimple_df->decls_to_pointers != NULL)
904 tree *namep = cfun->gimple_df->decls_to_pointers->get (x);
906 TREE_ADDRESSABLE (*namep) = 1;
910 /* Returns true iff T is a valid RHS for an assignment to a renamed
911 user -- or front-end generated artificial -- variable. */
914 is_gimple_reg_rhs (tree t)
916 return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
919 #include "gt-gimple-expr.h"