Daily bump.
[official-gcc.git] / gcc / tree-gimple.c
blob61d2ec74ace5cfc0d4745cd485ecee278ea08421
1 /* Functions to analyze and validate GIMPLE trees.
2 Copyright (C) 2002, 2003, 2004 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)
11 any later version.
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, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "ggc.h"
27 #include "tm.h"
28 #include "tree.h"
29 #include "tree-gimple.h"
30 #include "tree-flow.h"
31 #include "output.h"
32 #include "rtl.h"
33 #include "expr.h"
34 #include "bitmap.h"
36 /* For the definitive definition of GIMPLE, see doc/tree-ssa.texi. */
38 static inline bool is_gimple_id (tree);
40 /* Validation of GIMPLE expressions. */
42 /* Return true if T is a GIMPLE RHS for an assignment to a temporary. */
44 bool
45 is_gimple_formal_tmp_rhs (tree t)
47 enum tree_code code = TREE_CODE (t);
49 switch (TREE_CODE_CLASS (code))
51 case tcc_unary:
52 case tcc_binary:
53 case tcc_comparison:
54 return true;
56 default:
57 break;
60 switch (code)
62 case TRUTH_NOT_EXPR:
63 case TRUTH_AND_EXPR:
64 case TRUTH_OR_EXPR:
65 case TRUTH_XOR_EXPR:
66 case ADDR_EXPR:
67 case CALL_EXPR:
68 case CONSTRUCTOR:
69 case COMPLEX_EXPR:
70 case INTEGER_CST:
71 case REAL_CST:
72 case STRING_CST:
73 case COMPLEX_CST:
74 case VECTOR_CST:
75 case OBJ_TYPE_REF:
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 MODIFY_EXPR 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 V_MAY_DEF 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 return is_gimple_val (t);
121 else
122 return is_gimple_formal_tmp_rhs (t);
125 /* Returns the appropriate RHS predicate for this LHS. */
127 gimple_predicate
128 rhs_predicate_for (tree lhs)
130 if (is_gimple_formal_tmp_var (lhs))
131 return is_gimple_formal_tmp_rhs;
132 else if (is_gimple_reg (lhs))
133 return is_gimple_reg_rhs;
134 else
135 return is_gimple_mem_rhs;
138 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
140 bool
141 is_gimple_lvalue (tree t)
143 return (is_gimple_addressable (t)
144 || TREE_CODE (t) == WITH_SIZE_EXPR
145 /* These are complex lvalues, but don't have addresses, so they
146 go here. */
147 || TREE_CODE (t) == BIT_FIELD_REF);
150 /* Return true if T is a GIMPLE condition. */
152 bool
153 is_gimple_condexpr (tree t)
155 return (is_gimple_val (t) || COMPARISON_CLASS_P (t));
158 /* Return true if T is something whose address can be taken. */
160 bool
161 is_gimple_addressable (tree t)
163 return (is_gimple_id (t) || handled_component_p (t)
164 || INDIRECT_REF_P (t));
167 /* Return true if T is function invariant. Or rather a restricted
168 form of function invariant. */
170 bool
171 is_gimple_min_invariant (tree t)
173 switch (TREE_CODE (t))
175 case ADDR_EXPR:
176 return TREE_INVARIANT (t);
178 case INTEGER_CST:
179 case REAL_CST:
180 case STRING_CST:
181 case COMPLEX_CST:
182 case VECTOR_CST:
183 return !TREE_OVERFLOW (t);
185 default:
186 return false;
190 /* Return true if T looks like a valid GIMPLE statement. */
192 bool
193 is_gimple_stmt (tree t)
195 enum tree_code code = TREE_CODE (t);
197 if (IS_EMPTY_STMT (t))
198 return 1;
200 switch (code)
202 case BIND_EXPR:
203 case COND_EXPR:
204 /* These are only valid if they're void. */
205 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
207 case SWITCH_EXPR:
208 case GOTO_EXPR:
209 case RETURN_EXPR:
210 case LABEL_EXPR:
211 case CASE_LABEL_EXPR:
212 case TRY_CATCH_EXPR:
213 case TRY_FINALLY_EXPR:
214 case EH_FILTER_EXPR:
215 case CATCH_EXPR:
216 case ASM_EXPR:
217 case RESX_EXPR:
218 case PHI_NODE:
219 case STATEMENT_LIST:
220 /* These are always void. */
221 return true;
223 case CALL_EXPR:
224 case MODIFY_EXPR:
225 /* These are valid regardless of their type. */
226 return true;
228 default:
229 return false;
233 /* Return true if T is a variable. */
235 bool
236 is_gimple_variable (tree t)
238 return (TREE_CODE (t) == VAR_DECL
239 || TREE_CODE (t) == PARM_DECL
240 || TREE_CODE (t) == RESULT_DECL
241 || TREE_CODE (t) == SSA_NAME);
244 /* Return true if T is a GIMPLE identifier (something with an address). */
246 static inline bool
247 is_gimple_id (tree t)
249 return (is_gimple_variable (t)
250 || TREE_CODE (t) == FUNCTION_DECL
251 || TREE_CODE (t) == LABEL_DECL
252 || TREE_CODE (t) == CONST_DECL
253 /* Allow string constants, since they are addressable. */
254 || TREE_CODE (t) == STRING_CST);
257 /* Return true if TYPE is a suitable type for a scalar register variable. */
259 bool
260 is_gimple_reg_type (tree type)
262 return (!AGGREGATE_TYPE_P (type)
263 && TREE_CODE (type) != COMPLEX_TYPE);
267 /* Return true if T is a scalar register variable. */
269 bool
270 is_gimple_reg (tree t)
272 if (TREE_CODE (t) == SSA_NAME)
273 t = SSA_NAME_VAR (t);
275 if (!is_gimple_variable (t))
276 return false;
277 if (!is_gimple_reg_type (TREE_TYPE (t)))
278 return false;
280 /* A volatile decl is not acceptable because we can't reuse it as
281 needed. We need to copy it into a temp first. */
282 if (TREE_THIS_VOLATILE (t))
283 return false;
285 /* We define "registers" as things that can be renamed as needed,
286 which with our infrastructure does not apply to memory. */
287 if (needs_to_live_in_memory (t))
288 return false;
290 /* Hard register variables are an interesting case. For those that
291 are call-clobbered, we don't know where all the calls are, since
292 we don't (want to) take into account which operations will turn
293 into libcalls at the rtl level. For those that are call-saved,
294 we don't currently model the fact that calls may in fact change
295 global hard registers, nor do we examine ASM_CLOBBERS at the tree
296 level, and so miss variable changes that might imply. All around,
297 it seems safest to not do too much optimization with these at the
298 tree level at all. We'll have to rely on the rtl optimizers to
299 clean this up, as there we've got all the appropriate bits exposed. */
300 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
301 return false;
303 return true;
306 /* Returns true if T is a GIMPLE formal temporary variable. */
308 bool
309 is_gimple_formal_tmp_var (tree t)
311 if (TREE_CODE (t) == SSA_NAME)
312 return true;
314 return TREE_CODE (t) == VAR_DECL && DECL_GIMPLE_FORMAL_TEMP_P (t);
317 /* Returns true if T is a GIMPLE formal temporary register variable. */
319 bool
320 is_gimple_formal_tmp_reg (tree t)
322 /* The intent of this is to get hold of a value that won't change.
323 An SSA_NAME qualifies no matter if its of a user variable or not. */
324 if (TREE_CODE (t) == SSA_NAME)
325 return true;
327 /* We don't know the lifetime characteristics of user variables. */
328 if (!is_gimple_formal_tmp_var (t))
329 return false;
331 /* Finally, it must be capable of being placed in a register. */
332 return is_gimple_reg (t);
335 /* Return true if T is a GIMPLE variable whose address is not needed. */
337 bool
338 is_gimple_non_addressable (tree t)
340 if (TREE_CODE (t) == SSA_NAME)
341 t = SSA_NAME_VAR (t);
343 return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
346 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
348 bool
349 is_gimple_val (tree t)
351 /* Make loads from volatiles and memory vars explicit. */
352 if (is_gimple_variable (t)
353 && is_gimple_reg_type (TREE_TYPE (t))
354 && !is_gimple_reg (t))
355 return false;
357 /* FIXME make these decls. That can happen only when we expose the
358 entire landing-pad construct at the tree level. */
359 if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
360 return 1;
362 return (is_gimple_variable (t) || is_gimple_min_invariant (t));
365 /* Similarly, but accept hard registers as inputs to asm statements. */
367 bool
368 is_gimple_asm_val (tree t)
370 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
371 return true;
373 return is_gimple_val (t);
376 /* Return true if T is a GIMPLE minimal lvalue. */
378 bool
379 is_gimple_min_lval (tree t)
381 return (is_gimple_id (t)
382 || TREE_CODE (t) == INDIRECT_REF);
385 /* Return true if T is a typecast operation. */
387 bool
388 is_gimple_cast (tree t)
390 return (TREE_CODE (t) == NOP_EXPR
391 || TREE_CODE (t) == CONVERT_EXPR
392 || TREE_CODE (t) == FIX_TRUNC_EXPR
393 || TREE_CODE (t) == FIX_CEIL_EXPR
394 || TREE_CODE (t) == FIX_FLOOR_EXPR
395 || TREE_CODE (t) == FIX_ROUND_EXPR);
398 /* Return true if T is a valid op0 of a CALL_EXPR. */
400 bool
401 is_gimple_call_addr (tree t)
403 return (TREE_CODE (t) == OBJ_TYPE_REF
404 || is_gimple_val (t));
407 /* If T makes a function call, return the corresponding CALL_EXPR operand.
408 Otherwise, return NULL_TREE. */
410 tree
411 get_call_expr_in (tree t)
413 if (TREE_CODE (t) == MODIFY_EXPR)
414 t = TREE_OPERAND (t, 1);
415 if (TREE_CODE (t) == WITH_SIZE_EXPR)
416 t = TREE_OPERAND (t, 0);
417 if (TREE_CODE (t) == CALL_EXPR)
418 return t;
419 return NULL_TREE;
422 /* Given a memory reference expression T, return its base address.
423 The base address of a memory reference expression is the main
424 object being referenced. For instance, the base address for
425 'array[i].fld[j]' is 'array'. You can think of this as stripping
426 away the offset part from a memory address.
428 This function calls handled_component_p to strip away all the inner
429 parts of the memory reference until it reaches the base object. */
431 tree
432 get_base_address (tree t)
434 while (handled_component_p (t))
435 t = TREE_OPERAND (t, 0);
437 if (SSA_VAR_P (t)
438 || TREE_CODE (t) == STRING_CST
439 || TREE_CODE (t) == CONSTRUCTOR
440 || INDIRECT_REF_P (t))
441 return t;
442 else
443 return NULL_TREE;
446 void
447 recalculate_side_effects (tree t)
449 enum tree_code code = TREE_CODE (t);
450 int len = TREE_CODE_LENGTH (code);
451 int i;
453 switch (TREE_CODE_CLASS (code))
455 case tcc_expression:
456 switch (code)
458 case INIT_EXPR:
459 case MODIFY_EXPR:
460 case VA_ARG_EXPR:
461 case PREDECREMENT_EXPR:
462 case PREINCREMENT_EXPR:
463 case POSTDECREMENT_EXPR:
464 case POSTINCREMENT_EXPR:
465 /* All of these have side-effects, no matter what their
466 operands are. */
467 return;
469 default:
470 break;
472 /* Fall through. */
474 case tcc_comparison: /* a comparison expression */
475 case tcc_unary: /* a unary arithmetic expression */
476 case tcc_binary: /* a binary arithmetic expression */
477 case tcc_reference: /* a reference */
478 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
479 for (i = 0; i < len; ++i)
481 tree op = TREE_OPERAND (t, i);
482 if (op && TREE_SIDE_EFFECTS (op))
483 TREE_SIDE_EFFECTS (t) = 1;
485 break;
487 default:
488 /* Can never be used with non-expressions. */
489 gcc_unreachable ();