1 /* Functions to analyze and validate GIMPLE trees.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Contributed by Diego Novillo <dnovillo@redhat.com>
5 Rewritten by Jason Merrill <jason@redhat.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
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))
82 return is_gimple_lvalue (t) || is_gimple_val (t);
85 /* Returns true iff T is a valid RHS for an assignment to a renamed
86 user -- or front-end generated artificial -- variable. */
89 is_gimple_reg_rhs (tree t)
91 /* If the RHS of the GIMPLE_MODIFY_STMT may throw or make a nonlocal goto
92 and the LHS is a user variable, then we need to introduce a formal
93 temporary. This way the optimizers can determine that the user
94 variable is only modified if evaluation of the RHS does not throw.
96 Don't force a temp of a non-renamable type; the copy could be
97 arbitrarily expensive. Instead we will generate a VDEF for
100 if (is_gimple_reg_type (TREE_TYPE (t))
101 && ((TREE_CODE (t) == CALL_EXPR && TREE_SIDE_EFFECTS (t))
102 || tree_could_throw_p (t)))
105 return is_gimple_formal_tmp_rhs (t);
108 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
109 LHS, or for a call argument. */
112 is_gimple_mem_rhs (tree t)
114 /* If we're dealing with a renamable type, either source or dest must be
115 a renamed variable. Also force a temporary if the type doesn't need
116 to be stored in memory, since it's cheap and prevents erroneous
117 tailcalls (PR 17526). */
118 if (is_gimple_reg_type (TREE_TYPE (t))
119 || (TYPE_MODE (TREE_TYPE (t)) != BLKmode
120 && (TREE_CODE (t) != CALL_EXPR
121 || ! aggregate_value_p (t, t))))
122 return is_gimple_val (t);
124 return is_gimple_formal_tmp_rhs (t);
127 /* Returns the appropriate RHS predicate for this LHS. */
130 rhs_predicate_for (tree lhs)
132 if (is_gimple_formal_tmp_var (lhs))
133 return is_gimple_formal_tmp_rhs;
134 else if (is_gimple_reg (lhs))
135 return is_gimple_reg_rhs;
137 return is_gimple_mem_rhs;
140 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
143 is_gimple_lvalue (tree t)
145 return (is_gimple_addressable (t)
146 || TREE_CODE (t) == WITH_SIZE_EXPR
147 /* These are complex lvalues, but don't have addresses, so they
149 || TREE_CODE (t) == BIT_FIELD_REF);
152 /* Return true if T is a GIMPLE condition. */
155 is_gimple_condexpr (tree t)
157 return (is_gimple_val (t) || COMPARISON_CLASS_P (t));
160 /* Return true if T is something whose address can be taken. */
163 is_gimple_addressable (tree t)
165 return (is_gimple_id (t) || handled_component_p (t)
166 || INDIRECT_REF_P (t));
169 /* Return true if T is a GIMPLE minimal invariant. It's a restricted
170 form of function invariant. */
173 is_gimple_min_invariant (const_tree t)
175 switch (TREE_CODE (t))
178 return TREE_INVARIANT (t);
188 /* Vector constant constructors are gimple invariant. */
190 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
191 return TREE_CONSTANT (t);
200 /* Return true if T looks like a valid GIMPLE statement. */
203 is_gimple_stmt (tree t)
205 const enum tree_code code = TREE_CODE (t);
210 /* The only valid NOP_EXPR is the empty statement. */
211 return IS_EMPTY_STMT (t);
215 /* These are only valid if they're void. */
216 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
222 case CASE_LABEL_EXPR:
224 case TRY_FINALLY_EXPR:
227 case CHANGE_DYNAMIC_TYPE_EXPR:
235 case OMP_SECTIONS_SWITCH:
243 case OMP_ATOMIC_LOAD:
244 case OMP_ATOMIC_STORE:
245 /* These are always void. */
249 case GIMPLE_MODIFY_STMT:
250 /* These are valid regardless of their type. */
258 /* Return true if T is a variable. */
261 is_gimple_variable (tree t)
263 return (TREE_CODE (t) == VAR_DECL
264 || TREE_CODE (t) == PARM_DECL
265 || TREE_CODE (t) == RESULT_DECL
266 || TREE_CODE (t) == SSA_NAME);
269 /* Return true if T is a GIMPLE identifier (something with an address). */
272 is_gimple_id (tree t)
274 return (is_gimple_variable (t)
275 || TREE_CODE (t) == FUNCTION_DECL
276 || TREE_CODE (t) == LABEL_DECL
277 || TREE_CODE (t) == CONST_DECL
278 /* Allow string constants, since they are addressable. */
279 || TREE_CODE (t) == STRING_CST);
282 /* Return true if TYPE is a suitable type for a scalar register variable. */
285 is_gimple_reg_type (tree type)
287 return !AGGREGATE_TYPE_P (type);
290 /* Return true if T is a non-aggregate register variable. */
293 is_gimple_reg (tree t)
295 if (TREE_CODE (t) == SSA_NAME)
296 t = SSA_NAME_VAR (t);
301 if (!is_gimple_variable (t))
304 if (!is_gimple_reg_type (TREE_TYPE (t)))
307 /* A volatile decl is not acceptable because we can't reuse it as
308 needed. We need to copy it into a temp first. */
309 if (TREE_THIS_VOLATILE (t))
312 /* We define "registers" as things that can be renamed as needed,
313 which with our infrastructure does not apply to memory. */
314 if (needs_to_live_in_memory (t))
317 /* Hard register variables are an interesting case. For those that
318 are call-clobbered, we don't know where all the calls are, since
319 we don't (want to) take into account which operations will turn
320 into libcalls at the rtl level. For those that are call-saved,
321 we don't currently model the fact that calls may in fact change
322 global hard registers, nor do we examine ASM_CLOBBERS at the tree
323 level, and so miss variable changes that might imply. All around,
324 it seems safest to not do too much optimization with these at the
325 tree level at all. We'll have to rely on the rtl optimizers to
326 clean this up, as there we've got all the appropriate bits exposed. */
327 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
330 /* Complex values must have been put into ssa form. That is, no
331 assignments to the individual components. */
332 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
333 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
334 return DECL_GIMPLE_REG_P (t);
340 /* Returns true if T is a GIMPLE formal temporary variable. */
343 is_gimple_formal_tmp_var (tree t)
345 if (TREE_CODE (t) == SSA_NAME)
348 return TREE_CODE (t) == VAR_DECL && DECL_GIMPLE_FORMAL_TEMP_P (t);
351 /* Returns true if T is a GIMPLE formal temporary register variable. */
354 is_gimple_formal_tmp_reg (tree t)
356 /* The intent of this is to get hold of a value that won't change.
357 An SSA_NAME qualifies no matter if its of a user variable or not. */
358 if (TREE_CODE (t) == SSA_NAME)
361 /* We don't know the lifetime characteristics of user variables. */
362 if (!is_gimple_formal_tmp_var (t))
365 /* Finally, it must be capable of being placed in a register. */
366 return is_gimple_reg (t);
369 /* Return true if T is a GIMPLE variable whose address is not needed. */
372 is_gimple_non_addressable (tree t)
374 if (TREE_CODE (t) == SSA_NAME)
375 t = SSA_NAME_VAR (t);
377 return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
380 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
383 is_gimple_val (tree t)
385 /* Make loads from volatiles and memory vars explicit. */
386 if (is_gimple_variable (t)
387 && is_gimple_reg_type (TREE_TYPE (t))
388 && !is_gimple_reg (t))
391 /* FIXME make these decls. That can happen only when we expose the
392 entire landing-pad construct at the tree level. */
393 if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
396 return (is_gimple_variable (t) || is_gimple_min_invariant (t));
399 /* Similarly, but accept hard registers as inputs to asm statements. */
402 is_gimple_asm_val (tree t)
404 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
407 return is_gimple_val (t);
410 /* Return true if T is a GIMPLE minimal lvalue. */
413 is_gimple_min_lval (tree t)
415 return (is_gimple_id (t)
416 || TREE_CODE (t) == INDIRECT_REF);
419 /* Return true if T is a typecast operation. */
422 is_gimple_cast (tree t)
424 return (TREE_CODE (t) == NOP_EXPR
425 || TREE_CODE (t) == CONVERT_EXPR
426 || TREE_CODE (t) == FIX_TRUNC_EXPR);
429 /* Return true if T is a valid function operand of a CALL_EXPR. */
432 is_gimple_call_addr (tree t)
434 return (TREE_CODE (t) == OBJ_TYPE_REF
435 || is_gimple_val (t));
438 /* If T makes a function call, return the corresponding CALL_EXPR operand.
439 Otherwise, return NULL_TREE. */
442 get_call_expr_in (tree t)
444 /* FIXME tuples: delete the assertion below when conversion complete. */
445 gcc_assert (TREE_CODE (t) != MODIFY_EXPR);
446 if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
447 t = GIMPLE_STMT_OPERAND (t, 1);
448 if (TREE_CODE (t) == WITH_SIZE_EXPR)
449 t = TREE_OPERAND (t, 0);
450 if (TREE_CODE (t) == CALL_EXPR)
455 /* Given a memory reference expression T, return its base address.
456 The base address of a memory reference expression is the main
457 object being referenced. For instance, the base address for
458 'array[i].fld[j]' is 'array'. You can think of this as stripping
459 away the offset part from a memory address.
461 This function calls handled_component_p to strip away all the inner
462 parts of the memory reference until it reaches the base object. */
465 get_base_address (tree t)
467 while (handled_component_p (t))
468 t = TREE_OPERAND (t, 0);
471 || TREE_CODE (t) == STRING_CST
472 || TREE_CODE (t) == CONSTRUCTOR
473 || INDIRECT_REF_P (t))
480 recalculate_side_effects (tree t)
482 enum tree_code code = TREE_CODE (t);
483 int len = TREE_OPERAND_LENGTH (t);
486 switch (TREE_CODE_CLASS (code))
492 case GIMPLE_MODIFY_STMT:
494 case PREDECREMENT_EXPR:
495 case PREINCREMENT_EXPR:
496 case POSTDECREMENT_EXPR:
497 case POSTINCREMENT_EXPR:
498 /* All of these have side-effects, no matter what their
507 case tcc_comparison: /* a comparison expression */
508 case tcc_unary: /* a unary arithmetic expression */
509 case tcc_binary: /* a binary arithmetic expression */
510 case tcc_reference: /* a reference */
511 case tcc_vl_exp: /* a function call */
512 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
513 for (i = 0; i < len; ++i)
515 tree op = TREE_OPERAND (t, i);
516 if (op && TREE_SIDE_EFFECTS (op))
517 TREE_SIDE_EFFECTS (t) = 1;
522 /* Can never be used with non-expressions. */
527 /* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
528 a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
529 we failed to create one. */
532 canonicalize_cond_expr_cond (tree t)
534 /* For (bool)x use x != 0. */
535 if (TREE_CODE (t) == NOP_EXPR
536 && TREE_TYPE (t) == boolean_type_node)
538 tree top0 = TREE_OPERAND (t, 0);
539 t = build2 (NE_EXPR, TREE_TYPE (t),
540 top0, build_int_cst (TREE_TYPE (top0), 0));
542 /* For !x use x == 0. */
543 else if (TREE_CODE (t) == TRUTH_NOT_EXPR)
545 tree top0 = TREE_OPERAND (t, 0);
546 t = build2 (EQ_EXPR, TREE_TYPE (t),
547 top0, build_int_cst (TREE_TYPE (top0), 0));
549 /* For cmp ? 1 : 0 use cmp. */
550 else if (TREE_CODE (t) == COND_EXPR
551 && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
552 && integer_onep (TREE_OPERAND (t, 1))
553 && integer_zerop (TREE_OPERAND (t, 2)))
555 tree top0 = TREE_OPERAND (t, 0);
556 t = build2 (TREE_CODE (top0), TREE_TYPE (t),
557 TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
560 /* A valid conditional for a COND_EXPR is either a gimple value
561 or a comparison with two gimple value operands. */
562 if (is_gimple_val (t)
563 || (COMPARISON_CLASS_P (t)
564 && is_gimple_val (TREE_OPERAND (t, 0))
565 && is_gimple_val (TREE_OPERAND (t, 1))))