* opt-functions.awk (var_type): New function.
[official-gcc.git] / gcc / tree-gimple.c
blobe723b47217785948664b37756061f8a850318cd1
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)
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 case ASSERT_EXPR:
77 return true;
79 default:
80 break;
83 return is_gimple_lvalue (t) || is_gimple_val (t);
86 /* Returns true iff T is a valid RHS for an assignment to a renamed
87 user -- or front-end generated artificial -- variable. */
89 bool
90 is_gimple_reg_rhs (tree t)
92 /* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto
93 and the LHS is a user variable, then we need to introduce a formal
94 temporary. This way the optimizers can determine that the user
95 variable is only modified if evaluation of the RHS does not throw.
97 Don't force a temp of a non-renamable type; the copy could be
98 arbitrarily expensive. Instead we will generate a V_MAY_DEF for
99 the assignment. */
101 if (is_gimple_reg_type (TREE_TYPE (t))
102 && ((TREE_CODE (t) == CALL_EXPR && TREE_SIDE_EFFECTS (t))
103 || tree_could_throw_p (t)))
104 return false;
106 return is_gimple_formal_tmp_rhs (t);
109 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
110 LHS, or for a call argument. */
112 bool
113 is_gimple_mem_rhs (tree t)
115 /* If we're dealing with a renamable type, either source or dest must be
116 a renamed variable. Also force a temporary if the type doesn't need
117 to be stored in memory, since it's cheap and prevents erroneous
118 tailcalls (PR 17526). */
119 if (is_gimple_reg_type (TREE_TYPE (t))
120 || TYPE_MODE (TREE_TYPE (t)) != BLKmode)
121 return is_gimple_val (t);
122 else
123 return is_gimple_formal_tmp_rhs (t);
126 /* Returns the appropriate RHS predicate for this LHS. */
128 gimple_predicate
129 rhs_predicate_for (tree lhs)
131 if (is_gimple_formal_tmp_var (lhs))
132 return is_gimple_formal_tmp_rhs;
133 else if (is_gimple_reg (lhs))
134 return is_gimple_reg_rhs;
135 else
136 return is_gimple_mem_rhs;
139 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
141 bool
142 is_gimple_lvalue (tree t)
144 return (is_gimple_addressable (t)
145 || TREE_CODE (t) == WITH_SIZE_EXPR
146 /* These are complex lvalues, but don't have addresses, so they
147 go here. */
148 || TREE_CODE (t) == BIT_FIELD_REF);
151 /* Return true if T is a GIMPLE condition. */
153 bool
154 is_gimple_condexpr (tree t)
156 return (is_gimple_val (t) || COMPARISON_CLASS_P (t));
159 /* Return true if T is something whose address can be taken. */
161 bool
162 is_gimple_addressable (tree t)
164 return (is_gimple_id (t) || handled_component_p (t)
165 || INDIRECT_REF_P (t));
168 /* Return true if T is function invariant. Or rather a restricted
169 form of function invariant. */
171 bool
172 is_gimple_min_invariant (tree t)
174 switch (TREE_CODE (t))
176 case ADDR_EXPR:
177 return TREE_INVARIANT (t);
179 case INTEGER_CST:
180 case REAL_CST:
181 case STRING_CST:
182 case COMPLEX_CST:
183 case VECTOR_CST:
184 return true;
186 default:
187 return false;
191 /* Return true if T looks like a valid GIMPLE statement. */
193 bool
194 is_gimple_stmt (tree t)
196 enum tree_code code = TREE_CODE (t);
198 if (IS_EMPTY_STMT (t))
199 return 1;
201 switch (code)
203 case BIND_EXPR:
204 case COND_EXPR:
205 /* These are only valid if they're void. */
206 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
208 case SWITCH_EXPR:
209 case GOTO_EXPR:
210 case RETURN_EXPR:
211 case LABEL_EXPR:
212 case CASE_LABEL_EXPR:
213 case TRY_CATCH_EXPR:
214 case TRY_FINALLY_EXPR:
215 case EH_FILTER_EXPR:
216 case CATCH_EXPR:
217 case ASM_EXPR:
218 case RESX_EXPR:
219 case PHI_NODE:
220 case STATEMENT_LIST:
221 /* These are always void. */
222 return true;
224 case CALL_EXPR:
225 case MODIFY_EXPR:
226 /* These are valid regardless of their type. */
227 return true;
229 default:
230 return false;
234 /* Return true if T is a variable. */
236 bool
237 is_gimple_variable (tree t)
239 return (TREE_CODE (t) == VAR_DECL
240 || TREE_CODE (t) == PARM_DECL
241 || TREE_CODE (t) == RESULT_DECL
242 || TREE_CODE (t) == SSA_NAME);
245 /* Return true if T is a GIMPLE identifier (something with an address). */
247 static inline bool
248 is_gimple_id (tree t)
250 return (is_gimple_variable (t)
251 || TREE_CODE (t) == FUNCTION_DECL
252 || TREE_CODE (t) == LABEL_DECL
253 || TREE_CODE (t) == CONST_DECL
254 /* Allow string constants, since they are addressable. */
255 || TREE_CODE (t) == STRING_CST);
258 /* Return true if TYPE is a suitable type for a scalar register variable. */
260 bool
261 is_gimple_reg_type (tree type)
263 return (!AGGREGATE_TYPE_P (type)
264 && TREE_CODE (type) != COMPLEX_TYPE);
268 /* Return true if T is a scalar register variable. */
270 bool
271 is_gimple_reg (tree t)
273 if (TREE_CODE (t) == SSA_NAME)
274 t = SSA_NAME_VAR (t);
276 if (!is_gimple_variable (t))
277 return false;
278 if (!is_gimple_reg_type (TREE_TYPE (t)))
279 return false;
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))
284 return false;
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))
289 return false;
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))
302 return false;
304 return true;
307 /* Returns true if T is a GIMPLE formal temporary variable. */
309 bool
310 is_gimple_formal_tmp_var (tree t)
312 if (TREE_CODE (t) == SSA_NAME)
313 return true;
315 return TREE_CODE (t) == VAR_DECL && DECL_GIMPLE_FORMAL_TEMP_P (t);
318 /* Returns true if T is a GIMPLE formal temporary register variable. */
320 bool
321 is_gimple_formal_tmp_reg (tree t)
323 /* The intent of this is to get hold of a value that won't change.
324 An SSA_NAME qualifies no matter if its of a user variable or not. */
325 if (TREE_CODE (t) == SSA_NAME)
326 return true;
328 /* We don't know the lifetime characteristics of user variables. */
329 if (!is_gimple_formal_tmp_var (t))
330 return false;
332 /* Finally, it must be capable of being placed in a register. */
333 return is_gimple_reg (t);
336 /* Return true if T is a GIMPLE variable whose address is not needed. */
338 bool
339 is_gimple_non_addressable (tree t)
341 if (TREE_CODE (t) == SSA_NAME)
342 t = SSA_NAME_VAR (t);
344 return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
347 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
349 bool
350 is_gimple_val (tree t)
352 /* Make loads from volatiles and memory vars explicit. */
353 if (is_gimple_variable (t)
354 && is_gimple_reg_type (TREE_TYPE (t))
355 && !is_gimple_reg (t))
356 return false;
358 /* FIXME make these decls. That can happen only when we expose the
359 entire landing-pad construct at the tree level. */
360 if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
361 return 1;
363 return (is_gimple_variable (t) || is_gimple_min_invariant (t));
366 /* Similarly, but accept hard registers as inputs to asm statements. */
368 bool
369 is_gimple_asm_val (tree t)
371 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
372 return true;
374 return is_gimple_val (t);
377 /* Return true if T is a GIMPLE minimal lvalue. */
379 bool
380 is_gimple_min_lval (tree t)
382 return (is_gimple_id (t)
383 || TREE_CODE (t) == INDIRECT_REF);
386 /* Return true if T is a typecast operation. */
388 bool
389 is_gimple_cast (tree t)
391 return (TREE_CODE (t) == NOP_EXPR
392 || TREE_CODE (t) == CONVERT_EXPR
393 || TREE_CODE (t) == FIX_TRUNC_EXPR
394 || TREE_CODE (t) == FIX_CEIL_EXPR
395 || TREE_CODE (t) == FIX_FLOOR_EXPR
396 || TREE_CODE (t) == FIX_ROUND_EXPR);
399 /* Return true if T is a valid op0 of a CALL_EXPR. */
401 bool
402 is_gimple_call_addr (tree t)
404 return (TREE_CODE (t) == OBJ_TYPE_REF
405 || is_gimple_val (t));
408 /* If T makes a function call, return the corresponding CALL_EXPR operand.
409 Otherwise, return NULL_TREE. */
411 tree
412 get_call_expr_in (tree t)
414 if (TREE_CODE (t) == MODIFY_EXPR)
415 t = TREE_OPERAND (t, 1);
416 if (TREE_CODE (t) == WITH_SIZE_EXPR)
417 t = TREE_OPERAND (t, 0);
418 if (TREE_CODE (t) == CALL_EXPR)
419 return t;
420 return NULL_TREE;
423 /* Given a memory reference expression T, return its base address.
424 The base address of a memory reference expression is the main
425 object being referenced. For instance, the base address for
426 'array[i].fld[j]' is 'array'. You can think of this as stripping
427 away the offset part from a memory address.
429 This function calls handled_component_p to strip away all the inner
430 parts of the memory reference until it reaches the base object. */
432 tree
433 get_base_address (tree t)
435 while (handled_component_p (t))
436 t = TREE_OPERAND (t, 0);
438 if (SSA_VAR_P (t)
439 || TREE_CODE (t) == STRING_CST
440 || TREE_CODE (t) == CONSTRUCTOR
441 || INDIRECT_REF_P (t))
442 return t;
443 else
444 return NULL_TREE;
447 void
448 recalculate_side_effects (tree t)
450 enum tree_code code = TREE_CODE (t);
451 int len = TREE_CODE_LENGTH (code);
452 int i;
454 switch (TREE_CODE_CLASS (code))
456 case tcc_expression:
457 switch (code)
459 case INIT_EXPR:
460 case MODIFY_EXPR:
461 case VA_ARG_EXPR:
462 case PREDECREMENT_EXPR:
463 case PREINCREMENT_EXPR:
464 case POSTDECREMENT_EXPR:
465 case POSTINCREMENT_EXPR:
466 /* All of these have side-effects, no matter what their
467 operands are. */
468 return;
470 default:
471 break;
473 /* Fall through. */
475 case tcc_comparison: /* a comparison expression */
476 case tcc_unary: /* a unary arithmetic expression */
477 case tcc_binary: /* a binary arithmetic expression */
478 case tcc_reference: /* a reference */
479 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
480 for (i = 0; i < len; ++i)
482 tree op = TREE_OPERAND (t, i);
483 if (op && TREE_SIDE_EFFECTS (op))
484 TREE_SIDE_EFFECTS (t) = 1;
486 break;
488 default:
489 /* Can never be used with non-expressions. */
490 gcc_unreachable ();