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"
28 #include "hard-reg-set.h"
30 #include "fold-const.h"
31 #include "internal-fn.h"
33 #include "stringpool.h"
34 #include "gimple-ssa.h"
36 #include "stor-layout.h"
39 /* ----- Type related ----- */
41 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
42 useless type conversion, otherwise return false.
44 This function implicitly defines the middle-end type system. With
45 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
46 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
47 the following invariants shall be fulfilled:
49 1) useless_type_conversion_p is transitive.
50 If a < b and b < c then a < c.
52 2) useless_type_conversion_p is not symmetric.
53 From a < b does not follow a > b.
55 3) Types define the available set of operations applicable to values.
56 A type conversion is useless if the operations for the target type
57 is a subset of the operations for the source type. For example
58 casts to void* are useless, casts from void* are not (void* can't
59 be dereferenced or offsetted, but copied, hence its set of operations
60 is a strict subset of that of all other data pointer types). Casts
61 to const T* are useless (can't be written to), casts from const T*
65 useless_type_conversion_p (tree outer_type
, tree inner_type
)
67 /* Do the following before stripping toplevel qualifiers. */
68 if (POINTER_TYPE_P (inner_type
)
69 && POINTER_TYPE_P (outer_type
))
71 /* Do not lose casts between pointers to different address spaces. */
72 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
73 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)))
75 /* Do not lose casts to function pointer types. */
76 if ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
77 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
78 && !(TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
79 || TREE_CODE (TREE_TYPE (inner_type
)) == METHOD_TYPE
))
83 /* From now on qualifiers on value types do not matter. */
84 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
85 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
87 if (inner_type
== outer_type
)
90 /* If we know the canonical types, compare them. */
91 if (TYPE_CANONICAL (inner_type
)
92 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
))
95 /* Changes in machine mode are never useless conversions unless we
96 deal with aggregate types in which case we defer to later checks. */
97 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
)
98 && !AGGREGATE_TYPE_P (inner_type
))
101 /* If both the inner and outer types are integral types, then the
102 conversion is not necessary if they have the same mode and
103 signedness and precision, and both or neither are boolean. */
104 if (INTEGRAL_TYPE_P (inner_type
)
105 && INTEGRAL_TYPE_P (outer_type
))
107 /* Preserve changes in signedness or precision. */
108 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
109 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
112 /* Preserve conversions to/from BOOLEAN_TYPE if types are not
114 if (((TREE_CODE (inner_type
) == BOOLEAN_TYPE
)
115 != (TREE_CODE (outer_type
) == BOOLEAN_TYPE
))
116 && TYPE_PRECISION (outer_type
) != 1)
119 /* We don't need to preserve changes in the types minimum or
120 maximum value in general as these do not generate code
121 unless the types precisions are different. */
125 /* Scalar floating point types with the same mode are compatible. */
126 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
127 && SCALAR_FLOAT_TYPE_P (outer_type
))
130 /* Fixed point types with the same mode are compatible. */
131 else if (FIXED_POINT_TYPE_P (inner_type
)
132 && FIXED_POINT_TYPE_P (outer_type
))
135 /* We need to take special care recursing to pointed-to types. */
136 else if (POINTER_TYPE_P (inner_type
)
137 && POINTER_TYPE_P (outer_type
))
139 /* We do not care for const qualification of the pointed-to types
140 as const qualification has no semantic value to the middle-end. */
142 /* Otherwise pointers/references are equivalent. */
146 /* Recurse for complex types. */
147 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
148 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
149 return useless_type_conversion_p (TREE_TYPE (outer_type
),
150 TREE_TYPE (inner_type
));
152 /* Recurse for vector types with the same number of subparts. */
153 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
154 && TREE_CODE (outer_type
) == VECTOR_TYPE
155 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
156 return useless_type_conversion_p (TREE_TYPE (outer_type
),
157 TREE_TYPE (inner_type
));
159 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
160 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
162 /* Preserve string attributes. */
163 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
166 /* Conversions from array types with unknown extent to
167 array types with known extent are not useless. */
168 if (!TYPE_DOMAIN (inner_type
)
169 && TYPE_DOMAIN (outer_type
))
172 /* Nor are conversions from array types with non-constant size to
173 array types with constant size or to different size. */
174 if (TYPE_SIZE (outer_type
)
175 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
176 && (!TYPE_SIZE (inner_type
)
177 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
178 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
179 TYPE_SIZE (inner_type
))))
182 /* Check conversions between arrays with partially known extents.
183 If the array min/max values are constant they have to match.
184 Otherwise allow conversions to unknown and variable extents.
185 In particular this declares conversions that may change the
186 mode to BLKmode as useless. */
187 if (TYPE_DOMAIN (inner_type
)
188 && TYPE_DOMAIN (outer_type
)
189 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
191 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
192 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
193 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
194 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
196 /* After gimplification a variable min/max value carries no
197 additional information compared to a NULL value. All that
198 matters has been lowered to be part of the IL. */
199 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
200 inner_min
= NULL_TREE
;
201 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
202 outer_min
= NULL_TREE
;
203 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
204 inner_max
= NULL_TREE
;
205 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
206 outer_max
= NULL_TREE
;
208 /* Conversions NULL / variable <- cst are useless, but not
209 the other way around. */
212 || !tree_int_cst_equal (inner_min
, outer_min
)))
216 || !tree_int_cst_equal (inner_max
, outer_max
)))
220 /* Recurse on the element check. */
221 return useless_type_conversion_p (TREE_TYPE (outer_type
),
222 TREE_TYPE (inner_type
));
225 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
226 || TREE_CODE (inner_type
) == METHOD_TYPE
)
227 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
229 tree outer_parm
, inner_parm
;
231 /* If the return types are not compatible bail out. */
232 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
233 TREE_TYPE (inner_type
)))
236 /* Method types should belong to a compatible base class. */
237 if (TREE_CODE (inner_type
) == METHOD_TYPE
238 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
239 TYPE_METHOD_BASETYPE (inner_type
)))
242 /* A conversion to an unprototyped argument list is ok. */
243 if (!prototype_p (outer_type
))
246 /* If the unqualified argument types are compatible the conversion
248 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
251 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
252 inner_parm
= TYPE_ARG_TYPES (inner_type
);
253 outer_parm
&& inner_parm
;
254 outer_parm
= TREE_CHAIN (outer_parm
),
255 inner_parm
= TREE_CHAIN (inner_parm
))
256 if (!useless_type_conversion_p
257 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm
)),
258 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm
))))
261 /* If there is a mismatch in the number of arguments the functions
262 are not compatible. */
263 if (outer_parm
|| inner_parm
)
266 /* Defer to the target if necessary. */
267 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
268 return comp_type_attributes (outer_type
, inner_type
) != 0;
273 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
274 explicit conversions for types involving to be structurally
276 else if (AGGREGATE_TYPE_P (inner_type
)
277 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
284 /* ----- Decl related ----- */
286 /* Set sequence SEQ to be the GIMPLE body for function FN. */
289 gimple_set_body (tree fndecl
, gimple_seq seq
)
291 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
294 /* If FNDECL still does not have a function structure associated
295 with it, then it does not make sense for it to receive a
297 gcc_assert (seq
== NULL
);
300 fn
->gimple_body
= seq
;
304 /* Return the body of GIMPLE statements for function FN. After the
305 CFG pass, the function body doesn't exist anymore because it has
306 been split up into basic blocks. In this case, it returns
310 gimple_body (tree fndecl
)
312 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
313 return fn
? fn
->gimple_body
: NULL
;
316 /* Return true when FNDECL has Gimple body either in unlowered
319 gimple_has_body_p (tree fndecl
)
321 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
322 return (gimple_body (fndecl
) || (fn
&& fn
->cfg
));
325 /* Return a printable name for symbol DECL. */
328 gimple_decl_printable_name (tree decl
, int verbosity
)
330 if (!DECL_NAME (decl
))
333 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
335 const char *str
, *mangled_str
;
336 int dmgl_opts
= DMGL_NO_OPTS
;
340 dmgl_opts
= DMGL_VERBOSE
344 if (TREE_CODE (decl
) == FUNCTION_DECL
)
345 dmgl_opts
|= DMGL_PARAMS
;
348 mangled_str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
349 str
= cplus_demangle_v3 (mangled_str
, dmgl_opts
);
350 return (str
) ? str
: mangled_str
;
353 return IDENTIFIER_POINTER (DECL_NAME (decl
));
357 /* Create a new VAR_DECL and copy information from VAR to it. */
360 copy_var_decl (tree var
, tree name
, tree type
)
362 tree copy
= build_decl (DECL_SOURCE_LOCATION (var
), VAR_DECL
, name
, type
);
364 TREE_ADDRESSABLE (copy
) = TREE_ADDRESSABLE (var
);
365 TREE_THIS_VOLATILE (copy
) = TREE_THIS_VOLATILE (var
);
366 DECL_GIMPLE_REG_P (copy
) = DECL_GIMPLE_REG_P (var
);
367 DECL_ARTIFICIAL (copy
) = DECL_ARTIFICIAL (var
);
368 DECL_IGNORED_P (copy
) = DECL_IGNORED_P (var
);
369 DECL_CONTEXT (copy
) = DECL_CONTEXT (var
);
370 TREE_NO_WARNING (copy
) = TREE_NO_WARNING (var
);
371 TREE_USED (copy
) = 1;
372 DECL_SEEN_IN_BIND_EXPR_P (copy
) = 1;
373 DECL_ATTRIBUTES (copy
) = DECL_ATTRIBUTES (var
);
378 /* Strip off a legitimate source ending from the input string NAME of
379 length LEN. Rather than having to know the names used by all of
380 our front ends, we strip off an ending of a period followed by
381 up to five characters. (Java uses ".class".) */
384 remove_suffix (char *name
, int len
)
388 for (i
= 2; i
< 8 && len
> i
; i
++)
390 if (name
[len
- i
] == '.')
392 name
[len
- i
] = '\0';
398 /* Create a new temporary name with PREFIX. Return an identifier. */
400 static GTY(()) unsigned int tmp_var_id_num
;
403 create_tmp_var_name (const char *prefix
)
409 char *preftmp
= ASTRDUP (prefix
);
411 remove_suffix (preftmp
, strlen (preftmp
));
412 clean_symbol_name (preftmp
);
417 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
? prefix
: "T", tmp_var_id_num
++);
418 return get_identifier (tmp_name
);
421 /* Create a new temporary variable declaration of type TYPE.
422 Do NOT push it into the current binding. */
425 create_tmp_var_raw (tree type
, const char *prefix
)
429 tmp_var
= build_decl (input_location
,
430 VAR_DECL
, prefix
? create_tmp_var_name (prefix
) : NULL
,
433 /* The variable was declared by the compiler. */
434 DECL_ARTIFICIAL (tmp_var
) = 1;
435 /* And we don't want debug info for it. */
436 DECL_IGNORED_P (tmp_var
) = 1;
438 /* Make the variable writable. */
439 TREE_READONLY (tmp_var
) = 0;
441 DECL_EXTERNAL (tmp_var
) = 0;
442 TREE_STATIC (tmp_var
) = 0;
443 TREE_USED (tmp_var
) = 1;
448 /* Create a new temporary variable declaration of type TYPE. DO push the
449 variable into the current binding. Further, assume that this is called
450 only from gimplification or optimization, at which point the creation of
451 certain types are bugs. */
454 create_tmp_var (tree type
, const char *prefix
)
458 /* We don't allow types that are addressable (meaning we can't make copies),
459 or incomplete. We also used to reject every variable size objects here,
460 but now support those for which a constant upper bound can be obtained.
461 The processing for variable sizes is performed in gimple_add_tmp_var,
462 point at which it really matters and possibly reached via paths not going
463 through this function, e.g. after direct calls to create_tmp_var_raw. */
464 gcc_assert (!TREE_ADDRESSABLE (type
) && COMPLETE_TYPE_P (type
));
466 tmp_var
= create_tmp_var_raw (type
, prefix
);
467 gimple_add_tmp_var (tmp_var
);
471 /* Create a new temporary variable declaration of type TYPE by calling
472 create_tmp_var and if TYPE is a vector or a complex number, mark the new
473 temporary as gimple register. */
476 create_tmp_reg (tree type
, const char *prefix
)
480 tmp
= create_tmp_var (type
, prefix
);
481 if (TREE_CODE (type
) == COMPLEX_TYPE
482 || TREE_CODE (type
) == VECTOR_TYPE
)
483 DECL_GIMPLE_REG_P (tmp
) = 1;
488 /* Create a new temporary variable declaration of type TYPE by calling
489 create_tmp_var and if TYPE is a vector or a complex number, mark the new
490 temporary as gimple register. */
493 create_tmp_reg_fn (struct function
*fn
, tree type
, const char *prefix
)
497 tmp
= create_tmp_var_raw (type
, prefix
);
498 gimple_add_tmp_var_fn (fn
, tmp
);
499 if (TREE_CODE (type
) == COMPLEX_TYPE
500 || TREE_CODE (type
) == VECTOR_TYPE
)
501 DECL_GIMPLE_REG_P (tmp
) = 1;
507 /* ----- Expression related ----- */
509 /* Extract the operands and code for expression EXPR into *SUBCODE_P,
510 *OP1_P, *OP2_P and *OP3_P respectively. */
513 extract_ops_from_tree_1 (tree expr
, enum tree_code
*subcode_p
, tree
*op1_p
,
514 tree
*op2_p
, tree
*op3_p
)
516 enum gimple_rhs_class grhs_class
;
518 *subcode_p
= TREE_CODE (expr
);
519 grhs_class
= get_gimple_rhs_class (*subcode_p
);
521 if (grhs_class
== GIMPLE_TERNARY_RHS
)
523 *op1_p
= TREE_OPERAND (expr
, 0);
524 *op2_p
= TREE_OPERAND (expr
, 1);
525 *op3_p
= TREE_OPERAND (expr
, 2);
527 else if (grhs_class
== GIMPLE_BINARY_RHS
)
529 *op1_p
= TREE_OPERAND (expr
, 0);
530 *op2_p
= TREE_OPERAND (expr
, 1);
533 else if (grhs_class
== GIMPLE_UNARY_RHS
)
535 *op1_p
= TREE_OPERAND (expr
, 0);
539 else if (grhs_class
== GIMPLE_SINGLE_RHS
)
549 /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */
552 gimple_cond_get_ops_from_tree (tree cond
, enum tree_code
*code_p
,
553 tree
*lhs_p
, tree
*rhs_p
)
555 gcc_assert (COMPARISON_CLASS_P (cond
)
556 || TREE_CODE (cond
) == TRUTH_NOT_EXPR
557 || is_gimple_min_invariant (cond
)
558 || SSA_VAR_P (cond
));
560 extract_ops_from_tree (cond
, code_p
, lhs_p
, rhs_p
);
562 /* Canonicalize conditionals of the form 'if (!VAL)'. */
563 if (*code_p
== TRUTH_NOT_EXPR
)
566 gcc_assert (*lhs_p
&& *rhs_p
== NULL_TREE
);
567 *rhs_p
= build_zero_cst (TREE_TYPE (*lhs_p
));
569 /* Canonicalize conditionals of the form 'if (VAL)' */
570 else if (TREE_CODE_CLASS (*code_p
) != tcc_comparison
)
573 gcc_assert (*lhs_p
&& *rhs_p
== NULL_TREE
);
574 *rhs_p
= build_zero_cst (TREE_TYPE (*lhs_p
));
578 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
581 is_gimple_lvalue (tree t
)
583 return (is_gimple_addressable (t
)
584 || TREE_CODE (t
) == WITH_SIZE_EXPR
585 /* These are complex lvalues, but don't have addresses, so they
587 || TREE_CODE (t
) == BIT_FIELD_REF
);
590 /* Return true if T is a GIMPLE condition. */
593 is_gimple_condexpr (tree t
)
595 return (is_gimple_val (t
) || (COMPARISON_CLASS_P (t
)
596 && !tree_could_throw_p (t
)
597 && is_gimple_val (TREE_OPERAND (t
, 0))
598 && is_gimple_val (TREE_OPERAND (t
, 1))));
601 /* Return true if T is a gimple address. */
604 is_gimple_address (const_tree t
)
608 if (TREE_CODE (t
) != ADDR_EXPR
)
611 op
= TREE_OPERAND (t
, 0);
612 while (handled_component_p (op
))
614 if ((TREE_CODE (op
) == ARRAY_REF
615 || TREE_CODE (op
) == ARRAY_RANGE_REF
)
616 && !is_gimple_val (TREE_OPERAND (op
, 1)))
619 op
= TREE_OPERAND (op
, 0);
622 if (CONSTANT_CLASS_P (op
) || TREE_CODE (op
) == MEM_REF
)
625 switch (TREE_CODE (op
))
640 /* Return true if T is a gimple invariant address. */
643 is_gimple_invariant_address (const_tree t
)
647 if (TREE_CODE (t
) != ADDR_EXPR
)
650 op
= strip_invariant_refs (TREE_OPERAND (t
, 0));
654 if (TREE_CODE (op
) == MEM_REF
)
656 const_tree op0
= TREE_OPERAND (op
, 0);
657 return (TREE_CODE (op0
) == ADDR_EXPR
658 && (CONSTANT_CLASS_P (TREE_OPERAND (op0
, 0))
659 || decl_address_invariant_p (TREE_OPERAND (op0
, 0))));
662 return CONSTANT_CLASS_P (op
) || decl_address_invariant_p (op
);
665 /* Return true if T is a gimple invariant address at IPA level
666 (so addresses of variables on stack are not allowed). */
669 is_gimple_ip_invariant_address (const_tree t
)
673 if (TREE_CODE (t
) != ADDR_EXPR
)
676 op
= strip_invariant_refs (TREE_OPERAND (t
, 0));
680 if (TREE_CODE (op
) == MEM_REF
)
682 const_tree op0
= TREE_OPERAND (op
, 0);
683 return (TREE_CODE (op0
) == ADDR_EXPR
684 && (CONSTANT_CLASS_P (TREE_OPERAND (op0
, 0))
685 || decl_address_ip_invariant_p (TREE_OPERAND (op0
, 0))));
688 return CONSTANT_CLASS_P (op
) || decl_address_ip_invariant_p (op
);
691 /* Return true if T is a GIMPLE minimal invariant. It's a restricted
692 form of function invariant. */
695 is_gimple_min_invariant (const_tree t
)
697 if (TREE_CODE (t
) == ADDR_EXPR
)
698 return is_gimple_invariant_address (t
);
700 return is_gimple_constant (t
);
703 /* Return true if T is a GIMPLE interprocedural invariant. It's a restricted
704 form of gimple minimal invariant. */
707 is_gimple_ip_invariant (const_tree t
)
709 if (TREE_CODE (t
) == ADDR_EXPR
)
710 return is_gimple_ip_invariant_address (t
);
712 return is_gimple_constant (t
);
715 /* Return true if T is a non-aggregate register variable. */
718 is_gimple_reg (tree t
)
720 if (virtual_operand_p (t
))
723 if (TREE_CODE (t
) == SSA_NAME
)
726 if (!is_gimple_variable (t
))
729 if (!is_gimple_reg_type (TREE_TYPE (t
)))
732 /* A volatile decl is not acceptable because we can't reuse it as
733 needed. We need to copy it into a temp first. */
734 if (TREE_THIS_VOLATILE (t
))
737 /* We define "registers" as things that can be renamed as needed,
738 which with our infrastructure does not apply to memory. */
739 if (needs_to_live_in_memory (t
))
742 /* Hard register variables are an interesting case. For those that
743 are call-clobbered, we don't know where all the calls are, since
744 we don't (want to) take into account which operations will turn
745 into libcalls at the rtl level. For those that are call-saved,
746 we don't currently model the fact that calls may in fact change
747 global hard registers, nor do we examine ASM_CLOBBERS at the tree
748 level, and so miss variable changes that might imply. All around,
749 it seems safest to not do too much optimization with these at the
750 tree level at all. We'll have to rely on the rtl optimizers to
751 clean this up, as there we've got all the appropriate bits exposed. */
752 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
755 /* Complex and vector values must have been put into SSA-like form.
756 That is, no assignments to the individual components. */
757 if (TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
758 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
759 return DECL_GIMPLE_REG_P (t
);
765 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
768 is_gimple_val (tree t
)
770 /* Make loads from volatiles and memory vars explicit. */
771 if (is_gimple_variable (t
)
772 && is_gimple_reg_type (TREE_TYPE (t
))
773 && !is_gimple_reg (t
))
776 return (is_gimple_variable (t
) || is_gimple_min_invariant (t
));
779 /* Similarly, but accept hard registers as inputs to asm statements. */
782 is_gimple_asm_val (tree t
)
784 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
787 return is_gimple_val (t
);
790 /* Return true if T is a GIMPLE minimal lvalue. */
793 is_gimple_min_lval (tree t
)
795 if (!(t
= CONST_CAST_TREE (strip_invariant_refs (t
))))
797 return (is_gimple_id (t
) || TREE_CODE (t
) == MEM_REF
);
800 /* Return true if T is a valid function operand of a CALL_EXPR. */
803 is_gimple_call_addr (tree t
)
805 return (TREE_CODE (t
) == OBJ_TYPE_REF
|| is_gimple_val (t
));
808 /* Return true if T is a valid address operand of a MEM_REF. */
811 is_gimple_mem_ref_addr (tree t
)
813 return (is_gimple_reg (t
)
814 || TREE_CODE (t
) == INTEGER_CST
815 || (TREE_CODE (t
) == ADDR_EXPR
816 && (CONSTANT_CLASS_P (TREE_OPERAND (t
, 0))
817 || decl_address_invariant_p (TREE_OPERAND (t
, 0)))));
820 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
821 form and we don't do any syntax checking. */
824 mark_addressable (tree x
)
826 while (handled_component_p (x
))
827 x
= TREE_OPERAND (x
, 0);
828 if (TREE_CODE (x
) == MEM_REF
829 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
830 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
831 if (TREE_CODE (x
) != VAR_DECL
832 && TREE_CODE (x
) != PARM_DECL
833 && TREE_CODE (x
) != RESULT_DECL
)
835 TREE_ADDRESSABLE (x
) = 1;
837 /* Also mark the artificial SSA_NAME that points to the partition of X. */
838 if (TREE_CODE (x
) == VAR_DECL
839 && !DECL_EXTERNAL (x
)
841 && cfun
->gimple_df
!= NULL
842 && cfun
->gimple_df
->decls_to_pointers
!= NULL
)
844 tree
*namep
= cfun
->gimple_df
->decls_to_pointers
->get (x
);
846 TREE_ADDRESSABLE (*namep
) = 1;
850 /* Returns true iff T is a valid RHS for an assignment to a renamed
851 user -- or front-end generated artificial -- variable. */
854 is_gimple_reg_rhs (tree t
)
856 return get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
;
859 #include "gt-gimple-expr.h"