1 /* Functions to analyze and validate GIMPLE trees.
2 Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
4 Rewritten by Jason Merrill <jason@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
25 #include "coretypes.h"
29 #include "tree-gimple.h"
30 #include "tree-flow.h"
36 /* For the definitive definition of GIMPLE, see doc/tree-ssa.texi. */
38 /* Validation of GIMPLE expressions. */
40 /* Return true if T is a GIMPLE RHS for an assignment to a temporary. */
43 is_gimple_formal_tmp_rhs (tree t
)
45 enum tree_code code
= TREE_CODE (t
);
47 switch (TREE_CODE_CLASS (code
))
81 return is_gimple_lvalue (t
) || is_gimple_val (t
);
84 /* Returns true iff T is a valid RHS for an assignment to a renamed
85 user -- or front-end generated artificial -- variable. */
88 is_gimple_reg_rhs (tree t
)
90 /* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto
91 and the LHS is a user variable, then we need to introduce a formal
92 temporary. This way the optimizers can determine that the user
93 variable is only modified if evaluation of the RHS does not throw.
95 Don't force a temp of a non-renamable type; the copy could be
96 arbitrarily expensive. Instead we will generate a V_MAY_DEF for
99 if (is_gimple_reg_type (TREE_TYPE (t
))
100 && ((TREE_CODE (t
) == CALL_EXPR
&& TREE_SIDE_EFFECTS (t
))
101 || tree_could_throw_p (t
)))
104 return is_gimple_formal_tmp_rhs (t
);
107 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
108 LHS, or for a call argument. */
111 is_gimple_mem_rhs (tree t
)
113 /* If we're dealing with a renamable type, either source or dest must be
114 a renamed variable. Also force a temporary if the type doesn't need
115 to be stored in memory, since it's cheap and prevents erroneous
116 tailcalls (PR 17526). */
117 if (is_gimple_reg_type (TREE_TYPE (t
))
118 || TYPE_MODE (TREE_TYPE (t
)) != BLKmode
)
119 return is_gimple_val (t
);
121 return is_gimple_formal_tmp_rhs (t
);
124 /* Returns the appropriate RHS predicate for this LHS. */
127 rhs_predicate_for (tree lhs
)
129 if (is_gimple_formal_tmp_var (lhs
))
130 return is_gimple_formal_tmp_rhs
;
131 else if (is_gimple_reg (lhs
))
132 return is_gimple_reg_rhs
;
134 return is_gimple_mem_rhs
;
137 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
140 is_gimple_lvalue (tree t
)
142 return (is_gimple_addressable (t
)
143 || TREE_CODE (t
) == WITH_SIZE_EXPR
144 /* These are complex lvalues, but don't have addresses, so they
146 || TREE_CODE (t
) == BIT_FIELD_REF
);
149 /* Return true if T is a GIMPLE condition. */
152 is_gimple_condexpr (tree t
)
154 return (is_gimple_val (t
) || COMPARISON_CLASS_P (t
));
157 /* Return true if T is something whose address can be taken. */
160 is_gimple_addressable (tree t
)
162 return (is_gimple_id (t
) || handled_component_p (t
)
163 || INDIRECT_REF_P (t
));
166 /* Return true if T is function invariant. Or rather a restricted
167 form of function invariant. */
170 is_gimple_min_invariant (tree t
)
172 switch (TREE_CODE (t
))
175 return TREE_INVARIANT (t
);
189 /* Return true if T looks like a valid GIMPLE statement. */
192 is_gimple_stmt (tree t
)
194 enum tree_code code
= TREE_CODE (t
);
196 if (IS_EMPTY_STMT (t
))
203 /* These are only valid if they're void. */
204 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
210 case CASE_LABEL_EXPR
:
212 case TRY_FINALLY_EXPR
:
219 /* These are always void. */
224 /* These are valid regardless of their type. */
232 /* Return true if T is a variable. */
235 is_gimple_variable (tree t
)
237 return (TREE_CODE (t
) == VAR_DECL
238 || TREE_CODE (t
) == PARM_DECL
239 || TREE_CODE (t
) == RESULT_DECL
240 || TREE_CODE (t
) == SSA_NAME
);
243 /* Return true if T is a GIMPLE identifier (something with an address). */
246 is_gimple_id (tree t
)
248 return (is_gimple_variable (t
)
249 || TREE_CODE (t
) == FUNCTION_DECL
250 || TREE_CODE (t
) == LABEL_DECL
251 || TREE_CODE (t
) == CONST_DECL
252 /* Allow string constants, since they are addressable. */
253 || TREE_CODE (t
) == STRING_CST
);
256 /* Return true if TYPE is a suitable type for a scalar register variable. */
259 is_gimple_reg_type (tree type
)
261 return !AGGREGATE_TYPE_P (type
);
264 /* Return true if T is a non-aggregate register variable. */
267 is_gimple_reg (tree t
)
269 if (TREE_CODE (t
) == SSA_NAME
)
270 t
= SSA_NAME_VAR (t
);
275 if (!is_gimple_variable (t
))
278 if (!is_gimple_reg_type (TREE_TYPE (t
)))
281 /* A volatile decl is not acceptable because we can't reuse it as
282 needed. We need to copy it into a temp first. */
283 if (TREE_THIS_VOLATILE (t
))
286 /* We define "registers" as things that can be renamed as needed,
287 which with our infrastructure does not apply to memory. */
288 if (needs_to_live_in_memory (t
))
291 /* Hard register variables are an interesting case. For those that
292 are call-clobbered, we don't know where all the calls are, since
293 we don't (want to) take into account which operations will turn
294 into libcalls at the rtl level. For those that are call-saved,
295 we don't currently model the fact that calls may in fact change
296 global hard registers, nor do we examine ASM_CLOBBERS at the tree
297 level, and so miss variable changes that might imply. All around,
298 it seems safest to not do too much optimization with these at the
299 tree level at all. We'll have to rely on the rtl optimizers to
300 clean this up, as there we've got all the appropriate bits exposed. */
301 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
304 /* Complex values must have been put into ssa form. That is, no
305 assignments to the individual components. */
306 if (TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
)
307 return DECL_COMPLEX_GIMPLE_REG_P (t
);
313 /* Returns true if T is a GIMPLE formal temporary variable. */
316 is_gimple_formal_tmp_var (tree t
)
318 if (TREE_CODE (t
) == SSA_NAME
)
321 return TREE_CODE (t
) == VAR_DECL
&& DECL_GIMPLE_FORMAL_TEMP_P (t
);
324 /* Returns true if T is a GIMPLE formal temporary register variable. */
327 is_gimple_formal_tmp_reg (tree t
)
329 /* The intent of this is to get hold of a value that won't change.
330 An SSA_NAME qualifies no matter if its of a user variable or not. */
331 if (TREE_CODE (t
) == SSA_NAME
)
334 /* We don't know the lifetime characteristics of user variables. */
335 if (!is_gimple_formal_tmp_var (t
))
338 /* Finally, it must be capable of being placed in a register. */
339 return is_gimple_reg (t
);
342 /* Return true if T is a GIMPLE variable whose address is not needed. */
345 is_gimple_non_addressable (tree t
)
347 if (TREE_CODE (t
) == SSA_NAME
)
348 t
= SSA_NAME_VAR (t
);
350 return (is_gimple_variable (t
) && ! needs_to_live_in_memory (t
));
353 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
356 is_gimple_val (tree t
)
358 /* Make loads from volatiles and memory vars explicit. */
359 if (is_gimple_variable (t
)
360 && is_gimple_reg_type (TREE_TYPE (t
))
361 && !is_gimple_reg (t
))
364 /* FIXME make these decls. That can happen only when we expose the
365 entire landing-pad construct at the tree level. */
366 if (TREE_CODE (t
) == EXC_PTR_EXPR
|| TREE_CODE (t
) == FILTER_EXPR
)
369 return (is_gimple_variable (t
) || is_gimple_min_invariant (t
));
372 /* Similarly, but accept hard registers as inputs to asm statements. */
375 is_gimple_asm_val (tree t
)
377 if (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
))
380 return is_gimple_val (t
);
383 /* Return true if T is a GIMPLE minimal lvalue. */
386 is_gimple_min_lval (tree t
)
388 return (is_gimple_id (t
)
389 || TREE_CODE (t
) == INDIRECT_REF
);
392 /* Return true if T is a typecast operation. */
395 is_gimple_cast (tree t
)
397 return (TREE_CODE (t
) == NOP_EXPR
398 || TREE_CODE (t
) == CONVERT_EXPR
399 || TREE_CODE (t
) == FIX_TRUNC_EXPR
400 || TREE_CODE (t
) == FIX_CEIL_EXPR
401 || TREE_CODE (t
) == FIX_FLOOR_EXPR
402 || TREE_CODE (t
) == FIX_ROUND_EXPR
);
405 /* Return true if T is a valid op0 of a CALL_EXPR. */
408 is_gimple_call_addr (tree t
)
410 return (TREE_CODE (t
) == OBJ_TYPE_REF
411 || is_gimple_val (t
));
414 /* If T makes a function call, return the corresponding CALL_EXPR operand.
415 Otherwise, return NULL_TREE. */
418 get_call_expr_in (tree t
)
420 if (TREE_CODE (t
) == MODIFY_EXPR
)
421 t
= TREE_OPERAND (t
, 1);
422 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
423 t
= TREE_OPERAND (t
, 0);
424 if (TREE_CODE (t
) == CALL_EXPR
)
429 /* Given a memory reference expression T, return its base address.
430 The base address of a memory reference expression is the main
431 object being referenced. For instance, the base address for
432 'array[i].fld[j]' is 'array'. You can think of this as stripping
433 away the offset part from a memory address.
435 This function calls handled_component_p to strip away all the inner
436 parts of the memory reference until it reaches the base object. */
439 get_base_address (tree t
)
441 while (handled_component_p (t
))
442 t
= TREE_OPERAND (t
, 0);
445 || TREE_CODE (t
) == STRING_CST
446 || TREE_CODE (t
) == CONSTRUCTOR
447 || INDIRECT_REF_P (t
))
454 recalculate_side_effects (tree t
)
456 enum tree_code code
= TREE_CODE (t
);
457 int len
= TREE_CODE_LENGTH (code
);
460 switch (TREE_CODE_CLASS (code
))
468 case PREDECREMENT_EXPR
:
469 case PREINCREMENT_EXPR
:
470 case POSTDECREMENT_EXPR
:
471 case POSTINCREMENT_EXPR
:
472 /* All of these have side-effects, no matter what their
481 case tcc_comparison
: /* a comparison expression */
482 case tcc_unary
: /* a unary arithmetic expression */
483 case tcc_binary
: /* a binary arithmetic expression */
484 case tcc_reference
: /* a reference */
485 TREE_SIDE_EFFECTS (t
) = TREE_THIS_VOLATILE (t
);
486 for (i
= 0; i
< len
; ++i
)
488 tree op
= TREE_OPERAND (t
, i
);
489 if (op
&& TREE_SIDE_EFFECTS (op
))
490 TREE_SIDE_EFFECTS (t
) = 1;
495 /* Can never be used with non-expressions. */