fortran frontend:
[official-gcc.git] / gcc / tree-gimple.c
blob16caf0ad573b024656d1b3c3960aedbece9bbabd
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 2, or (at your option)
12 any later version.
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 COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "ggc.h"
28 #include "tm.h"
29 #include "tree.h"
30 #include "tree-gimple.h"
31 #include "tree-flow.h"
32 #include "output.h"
33 #include "rtl.h"
34 #include "expr.h"
35 #include "bitmap.h"
37 /* For the definitive definition of GIMPLE, see doc/tree-ssa.texi. */
39 /* Validation of GIMPLE expressions. */
41 /* Return true if T is a GIMPLE RHS for an assignment to a temporary. */
43 bool
44 is_gimple_formal_tmp_rhs (tree t)
46 enum tree_code code = TREE_CODE (t);
48 switch (TREE_CODE_CLASS (code))
50 case tcc_unary:
51 case tcc_binary:
52 case tcc_comparison:
53 return true;
55 default:
56 break;
59 switch (code)
61 case TRUTH_NOT_EXPR:
62 case TRUTH_AND_EXPR:
63 case TRUTH_OR_EXPR:
64 case TRUTH_XOR_EXPR:
65 case ADDR_EXPR:
66 case CALL_EXPR:
67 case CONSTRUCTOR:
68 case COMPLEX_EXPR:
69 case INTEGER_CST:
70 case REAL_CST:
71 case STRING_CST:
72 case COMPLEX_CST:
73 case VECTOR_CST:
74 case OBJ_TYPE_REF:
75 case ASSERT_EXPR:
76 return true;
78 default:
79 break;
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. */
88 bool
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
98 the assignment. */
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)))
103 return false;
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. */
111 bool
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);
123 else
124 return is_gimple_formal_tmp_rhs (t);
127 /* Returns the appropriate RHS predicate for this LHS. */
129 gimple_predicate
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;
136 else
137 return is_gimple_mem_rhs;
140 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
142 bool
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
148 go here. */
149 || TREE_CODE (t) == BIT_FIELD_REF);
152 /* Return true if T is a GIMPLE condition. */
154 bool
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. */
162 bool
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 function invariant. Or rather a restricted
170 form of function invariant. */
172 bool
173 is_gimple_min_invariant (tree t)
175 switch (TREE_CODE (t))
177 case ADDR_EXPR:
178 return TREE_INVARIANT (t);
180 case INTEGER_CST:
181 case REAL_CST:
182 case STRING_CST:
183 case COMPLEX_CST:
184 case VECTOR_CST:
185 return true;
187 /* Vector constant constructors are gimple invariant. */
188 case CONSTRUCTOR:
189 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
190 return TREE_CONSTANT (t);
191 else
192 return false;
194 default:
195 return false;
199 /* Return true if T looks like a valid GIMPLE statement. */
201 bool
202 is_gimple_stmt (tree t)
204 enum tree_code code = TREE_CODE (t);
206 switch (code)
208 case NOP_EXPR:
209 /* The only valid NOP_EXPR is the empty statement. */
210 return IS_EMPTY_STMT (t);
212 case BIND_EXPR:
213 case COND_EXPR:
214 /* These are only valid if they're void. */
215 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
217 case SWITCH_EXPR:
218 case GOTO_EXPR:
219 case RETURN_EXPR:
220 case LABEL_EXPR:
221 case CASE_LABEL_EXPR:
222 case TRY_CATCH_EXPR:
223 case TRY_FINALLY_EXPR:
224 case EH_FILTER_EXPR:
225 case CATCH_EXPR:
226 case CHANGE_DYNAMIC_TYPE_EXPR:
227 case ASM_EXPR:
228 case RESX_EXPR:
229 case PHI_NODE:
230 case STATEMENT_LIST:
231 case OMP_PARALLEL:
232 case OMP_FOR:
233 case OMP_SECTIONS:
234 case OMP_SECTION:
235 case OMP_SINGLE:
236 case OMP_MASTER:
237 case OMP_ORDERED:
238 case OMP_CRITICAL:
239 case OMP_RETURN:
240 case OMP_CONTINUE:
241 /* These are always void. */
242 return true;
244 case CALL_EXPR:
245 case GIMPLE_MODIFY_STMT:
246 /* These are valid regardless of their type. */
247 return true;
249 default:
250 return false;
254 /* Return true if T is a variable. */
256 bool
257 is_gimple_variable (tree t)
259 return (TREE_CODE (t) == VAR_DECL
260 || TREE_CODE (t) == PARM_DECL
261 || TREE_CODE (t) == RESULT_DECL
262 || TREE_CODE (t) == SSA_NAME);
265 /* Return true if T is a GIMPLE identifier (something with an address). */
267 bool
268 is_gimple_id (tree t)
270 return (is_gimple_variable (t)
271 || TREE_CODE (t) == FUNCTION_DECL
272 || TREE_CODE (t) == LABEL_DECL
273 || TREE_CODE (t) == CONST_DECL
274 /* Allow string constants, since they are addressable. */
275 || TREE_CODE (t) == STRING_CST);
278 /* Return true if TYPE is a suitable type for a scalar register variable. */
280 bool
281 is_gimple_reg_type (tree type)
283 return !AGGREGATE_TYPE_P (type);
286 /* Return true if T is a non-aggregate register variable. */
288 bool
289 is_gimple_reg (tree t)
291 if (TREE_CODE (t) == SSA_NAME)
292 t = SSA_NAME_VAR (t);
294 if (MTAG_P (t))
295 return false;
297 if (!is_gimple_variable (t))
298 return false;
300 if (!is_gimple_reg_type (TREE_TYPE (t)))
301 return false;
303 /* A volatile decl is not acceptable because we can't reuse it as
304 needed. We need to copy it into a temp first. */
305 if (TREE_THIS_VOLATILE (t))
306 return false;
308 /* We define "registers" as things that can be renamed as needed,
309 which with our infrastructure does not apply to memory. */
310 if (needs_to_live_in_memory (t))
311 return false;
313 /* Hard register variables are an interesting case. For those that
314 are call-clobbered, we don't know where all the calls are, since
315 we don't (want to) take into account which operations will turn
316 into libcalls at the rtl level. For those that are call-saved,
317 we don't currently model the fact that calls may in fact change
318 global hard registers, nor do we examine ASM_CLOBBERS at the tree
319 level, and so miss variable changes that might imply. All around,
320 it seems safest to not do too much optimization with these at the
321 tree level at all. We'll have to rely on the rtl optimizers to
322 clean this up, as there we've got all the appropriate bits exposed. */
323 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
324 return false;
326 /* Complex values must have been put into ssa form. That is, no
327 assignments to the individual components. */
328 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
329 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
330 return DECL_GIMPLE_REG_P (t);
332 return true;
336 /* Returns true if T is a GIMPLE formal temporary variable. */
338 bool
339 is_gimple_formal_tmp_var (tree t)
341 if (TREE_CODE (t) == SSA_NAME)
342 return true;
344 return TREE_CODE (t) == VAR_DECL && DECL_GIMPLE_FORMAL_TEMP_P (t);
347 /* Returns true if T is a GIMPLE formal temporary register variable. */
349 bool
350 is_gimple_formal_tmp_reg (tree t)
352 /* The intent of this is to get hold of a value that won't change.
353 An SSA_NAME qualifies no matter if its of a user variable or not. */
354 if (TREE_CODE (t) == SSA_NAME)
355 return true;
357 /* We don't know the lifetime characteristics of user variables. */
358 if (!is_gimple_formal_tmp_var (t))
359 return false;
361 /* Finally, it must be capable of being placed in a register. */
362 return is_gimple_reg (t);
365 /* Return true if T is a GIMPLE variable whose address is not needed. */
367 bool
368 is_gimple_non_addressable (tree t)
370 if (TREE_CODE (t) == SSA_NAME)
371 t = SSA_NAME_VAR (t);
373 return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
376 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
378 bool
379 is_gimple_val (tree t)
381 /* Make loads from volatiles and memory vars explicit. */
382 if (is_gimple_variable (t)
383 && is_gimple_reg_type (TREE_TYPE (t))
384 && !is_gimple_reg (t))
385 return false;
387 /* FIXME make these decls. That can happen only when we expose the
388 entire landing-pad construct at the tree level. */
389 if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
390 return true;
392 return (is_gimple_variable (t) || is_gimple_min_invariant (t));
395 /* Similarly, but accept hard registers as inputs to asm statements. */
397 bool
398 is_gimple_asm_val (tree t)
400 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
401 return true;
403 return is_gimple_val (t);
406 /* Return true if T is a GIMPLE minimal lvalue. */
408 bool
409 is_gimple_min_lval (tree t)
411 return (is_gimple_id (t)
412 || TREE_CODE (t) == INDIRECT_REF);
415 /* Return true if T is a typecast operation. */
417 bool
418 is_gimple_cast (tree t)
420 return (TREE_CODE (t) == NOP_EXPR
421 || TREE_CODE (t) == CONVERT_EXPR
422 || TREE_CODE (t) == FIX_TRUNC_EXPR);
425 /* Return true if T is a valid function operand of a CALL_EXPR. */
427 bool
428 is_gimple_call_addr (tree t)
430 return (TREE_CODE (t) == OBJ_TYPE_REF
431 || is_gimple_val (t));
434 /* If T makes a function call, return the corresponding CALL_EXPR operand.
435 Otherwise, return NULL_TREE. */
437 tree
438 get_call_expr_in (tree t)
440 /* FIXME tuples: delete the assertion below when conversion complete. */
441 gcc_assert (TREE_CODE (t) != MODIFY_EXPR);
442 if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
443 t = GIMPLE_STMT_OPERAND (t, 1);
444 if (TREE_CODE (t) == WITH_SIZE_EXPR)
445 t = TREE_OPERAND (t, 0);
446 if (TREE_CODE (t) == CALL_EXPR)
447 return t;
448 return NULL_TREE;
451 /* Given a memory reference expression T, return its base address.
452 The base address of a memory reference expression is the main
453 object being referenced. For instance, the base address for
454 'array[i].fld[j]' is 'array'. You can think of this as stripping
455 away the offset part from a memory address.
457 This function calls handled_component_p to strip away all the inner
458 parts of the memory reference until it reaches the base object. */
460 tree
461 get_base_address (tree t)
463 while (handled_component_p (t))
464 t = TREE_OPERAND (t, 0);
466 if (SSA_VAR_P (t)
467 || TREE_CODE (t) == STRING_CST
468 || TREE_CODE (t) == CONSTRUCTOR
469 || INDIRECT_REF_P (t))
470 return t;
471 else
472 return NULL_TREE;
475 void
476 recalculate_side_effects (tree t)
478 enum tree_code code = TREE_CODE (t);
479 int len = TREE_OPERAND_LENGTH (t);
480 int i;
482 switch (TREE_CODE_CLASS (code))
484 case tcc_expression:
485 switch (code)
487 case INIT_EXPR:
488 case GIMPLE_MODIFY_STMT:
489 case VA_ARG_EXPR:
490 case PREDECREMENT_EXPR:
491 case PREINCREMENT_EXPR:
492 case POSTDECREMENT_EXPR:
493 case POSTINCREMENT_EXPR:
494 /* All of these have side-effects, no matter what their
495 operands are. */
496 return;
498 default:
499 break;
501 /* Fall through. */
503 case tcc_comparison: /* a comparison expression */
504 case tcc_unary: /* a unary arithmetic expression */
505 case tcc_binary: /* a binary arithmetic expression */
506 case tcc_reference: /* a reference */
507 case tcc_vl_exp: /* a function call */
508 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
509 for (i = 0; i < len; ++i)
511 tree op = TREE_OPERAND (t, i);
512 if (op && TREE_SIDE_EFFECTS (op))
513 TREE_SIDE_EFFECTS (t) = 1;
515 break;
517 default:
518 /* Can never be used with non-expressions. */
519 gcc_unreachable ();