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)
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. */
25 #include "coretypes.h"
29 #include "tree-gimple.h"
30 #include "tree-flow.h"
36 /* GCC GIMPLE structure
38 Inspired by the SIMPLE C grammar at
40 http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
42 function : FUNCTION_DECL
43 DECL_SAVED_TREE -> compound-stmt
45 compound-stmt: STATEMENT_LIST
60 BIND_EXPR_VARS -> chain of DECLs
61 BIND_EXPR_BLOCK -> BLOCK
62 BIND_EXPR_BODY -> compound-stmt
69 switch-stmt : SWITCH_EXPR
72 op2 -> TREE_VEC of CASE_LABEL_EXPRs
73 The CASE_LABEL_EXPRs are sorted by CASE_LOW,
77 op0 -> LABEL_DECL | val
79 return-stmt : RETURN_EXPR
90 label-stmt : LABEL_EXPR
93 try-stmt : TRY_CATCH_EXPR
104 catch-seq : STATEMENT_LIST
105 members -> CATCH_EXPR
107 modify-stmt : MODIFY_EXPR
111 call-stmt : CALL_EXPR
112 op0 -> val | OBJ_TYPE_REF
115 call-arg-list: TREE_LIST
121 with-size-arg: addr-expr-arg
125 indirectref : INDIRECT_REF
138 bitfieldref : BIT_FIELD_REF
143 compref : inner-compref
149 inner-compref: min-lval
190 static inline bool is_gimple_id (tree);
192 /* Validation of GIMPLE expressions. */
194 /* Return true if T is a GIMPLE RHS for an assignment to a temporary. */
197 is_gimple_tmp_rhs (tree t)
199 enum tree_code code = TREE_CODE (t);
201 switch (TREE_CODE_CLASS (code))
234 return is_gimple_lvalue (t) || is_gimple_val (t);
237 /* Returns true iff T is a valid RHS for an assignment to a renamed user
241 is_gimple_reg_rhs (tree t)
243 /* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto and
244 the LHS is a user variable, then we need to introduce a temporary.
245 ie temp = RHS; LHS = temp.
247 This way the optimizers can determine that the user variable is
248 only modified if evaluation of the RHS does not throw. */
249 if (is_gimple_reg_type (TREE_TYPE (t))
250 && TREE_SIDE_EFFECTS (t)
251 && (TREE_CODE (t) == CALL_EXPR
252 || (flag_non_call_exceptions && tree_could_trap_p (t))))
253 return is_gimple_val (t);
255 /* Don't force a temp of a non-renamable type; the copy could be
256 arbitrarily expensive. Instead we will generate a V_MAY_DEF for
258 return is_gimple_tmp_rhs (t);
261 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
262 LHS, or for a call argument. */
265 is_gimple_mem_rhs (tree t)
267 /* If we're dealing with a renamable type, either source or dest
268 must be a renamed variable. */
269 if (is_gimple_reg_type (TREE_TYPE (t)))
270 return is_gimple_val (t);
272 return is_gimple_tmp_rhs (t);
275 /* Returns the appropriate RHS predicate for this LHS. */
278 rhs_predicate_for (tree lhs)
280 if (is_gimple_tmp_var (lhs))
281 return is_gimple_tmp_rhs;
282 else if (is_gimple_reg (lhs))
283 return is_gimple_reg_rhs;
285 return is_gimple_mem_rhs;
288 /* Returns true if T is a valid CONSTRUCTOR component in GIMPLE, either
289 a val or another CONSTRUCTOR. */
292 is_gimple_constructor_elt (tree t)
294 return (is_gimple_val (t)
295 || TREE_CODE (t) == CONSTRUCTOR);
298 /* Return true if T is a valid LHS for a GIMPLE assignment expression. */
301 is_gimple_lvalue (tree t)
303 return (is_gimple_addr_expr_arg (t)
304 || TREE_CODE (t) == INDIRECT_REF
305 || TREE_CODE (t) == WITH_SIZE_EXPR
306 /* These are complex lvalues, but don't have addresses, so they
308 || TREE_CODE (t) == BIT_FIELD_REF);
311 /* Return true if T is a GIMPLE condition. */
314 is_gimple_condexpr (tree t)
316 return (is_gimple_val (t)
317 || TREE_CODE_CLASS (TREE_CODE (t)) == '<');
320 /* Return true if T is a valid operand for ADDR_EXPR. */
323 is_gimple_addr_expr_arg (tree t)
325 return (is_gimple_id (t)
326 || TREE_CODE (t) == ARRAY_REF
327 || TREE_CODE (t) == ARRAY_RANGE_REF
328 || TREE_CODE (t) == COMPONENT_REF
329 || TREE_CODE (t) == REALPART_EXPR
330 || TREE_CODE (t) == IMAGPART_EXPR
331 || TREE_CODE (t) == INDIRECT_REF);
334 /* Return true if T is function invariant. Or rather a restricted
335 form of function invariant. */
338 is_gimple_min_invariant (tree t)
340 switch (TREE_CODE (t))
343 return TREE_INVARIANT (t);
350 return !TREE_OVERFLOW (t);
357 /* Return true if T looks like a valid GIMPLE statement. */
360 is_gimple_stmt (tree t)
362 enum tree_code code = TREE_CODE (t);
364 if (IS_EMPTY_STMT (t))
371 /* These are only valid if they're void. */
372 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
378 case CASE_LABEL_EXPR:
380 case TRY_FINALLY_EXPR:
387 /* These are always void. */
392 /* These are valid regardless of their type. */
400 /* Return true if T is a variable. */
403 is_gimple_variable (tree t)
405 return (TREE_CODE (t) == VAR_DECL
406 || TREE_CODE (t) == PARM_DECL
407 || TREE_CODE (t) == RESULT_DECL
408 || TREE_CODE (t) == SSA_NAME);
411 /* Return true if T is a GIMPLE identifier (something with an address). */
414 is_gimple_id (tree t)
416 return (is_gimple_variable (t)
417 || TREE_CODE (t) == FUNCTION_DECL
418 || TREE_CODE (t) == LABEL_DECL
419 /* Allow string constants, since they are addressable. */
420 || TREE_CODE (t) == STRING_CST);
423 /* Return true if TYPE is a suitable type for a scalar register variable. */
426 is_gimple_reg_type (tree type)
428 return (!AGGREGATE_TYPE_P (type)
429 && TREE_CODE (type) != COMPLEX_TYPE);
433 /* Return true if T is a scalar register variable. */
436 is_gimple_reg (tree t)
438 if (TREE_CODE (t) == SSA_NAME)
439 t = SSA_NAME_VAR (t);
441 return (is_gimple_variable (t)
442 && is_gimple_reg_type (TREE_TYPE (t))
443 /* A volatile decl is not acceptable because we can't reuse it as
444 needed. We need to copy it into a temp first. */
445 && ! TREE_THIS_VOLATILE (t)
446 && ! TREE_ADDRESSABLE (t)
447 && ! needs_to_live_in_memory (t));
450 /* Returns true if T is a GIMPLE temporary variable, false otherwise. */
453 is_gimple_tmp_var (tree t)
455 /* FIXME this could trigger for other local artificials, too. */
456 return (TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t)
457 && !TREE_STATIC (t) && !DECL_EXTERNAL (t));
460 /* Returns true if T is a GIMPLE temporary register variable. */
463 is_gimple_tmp_reg (tree t)
465 /* The intent of this is to get hold of a value that won't change.
466 An SSA_NAME qualifies no matter if its of a user variable or not. */
467 if (TREE_CODE (t) == SSA_NAME)
470 /* We don't know the lifetime characteristics of user variables. */
471 if (TREE_CODE (t) != VAR_DECL || !DECL_ARTIFICIAL (t))
474 /* Finally, it must be capable of being placed in a register. */
475 return is_gimple_reg (t);
478 /* Return true if T is a GIMPLE variable whose address is not needed. */
481 is_gimple_non_addressable (tree t)
483 if (TREE_CODE (t) == SSA_NAME)
484 t = SSA_NAME_VAR (t);
486 return (is_gimple_variable (t)
487 && ! TREE_ADDRESSABLE (t)
488 && ! needs_to_live_in_memory (t));
491 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
494 is_gimple_val (tree t)
496 /* Make loads from volatiles and memory vars explicit. */
497 if (is_gimple_variable (t)
498 && is_gimple_reg_type (TREE_TYPE (t))
499 && !is_gimple_reg (t))
502 /* FIXME make these decls. That can happen only when we expose the
503 entire landing-pad construct at the tree level. */
504 if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
507 return (is_gimple_variable (t) || is_gimple_min_invariant (t));
511 /* Return true if T is a GIMPLE minimal lvalue. */
514 is_gimple_min_lval (tree t)
516 return (is_gimple_id (t)
517 || TREE_CODE (t) == INDIRECT_REF);
520 /* Return true if T is a typecast operation. */
523 is_gimple_cast (tree t)
525 return (TREE_CODE (t) == NOP_EXPR
526 || TREE_CODE (t) == CONVERT_EXPR
527 || TREE_CODE (t) == FIX_TRUNC_EXPR
528 || TREE_CODE (t) == FIX_CEIL_EXPR
529 || TREE_CODE (t) == FIX_FLOOR_EXPR
530 || TREE_CODE (t) == FIX_ROUND_EXPR);
533 /* Return true if T is a valid op0 of a CALL_EXPR. */
536 is_gimple_call_addr (tree t)
538 return (TREE_CODE (t) == OBJ_TYPE_REF
539 || is_gimple_val (t));
542 /* If T makes a function call, return the corresponding CALL_EXPR operand.
543 Otherwise, return NULL_TREE. */
546 get_call_expr_in (tree t)
548 if (TREE_CODE (t) == MODIFY_EXPR)
549 t = TREE_OPERAND (t, 1);
550 if (TREE_CODE (t) == WITH_SIZE_EXPR)
551 t = TREE_OPERAND (t, 0);
552 if (TREE_CODE (t) == CALL_EXPR)
557 /* Given a memory reference expression, return the base address. Note that,
558 in contrast with get_base_var, this will not recurse inside INDIRECT_REF
559 expressions. Therefore, given the reference PTR->FIELD, this function
560 will return *PTR. Whereas get_base_var would've returned PTR. */
563 get_base_address (tree t)
565 while (TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR
566 || handled_component_p (t))
567 t = TREE_OPERAND (t, 0);
570 || TREE_CODE (t) == STRING_CST
571 || TREE_CODE (t) == CONSTRUCTOR
572 || TREE_CODE (t) == INDIRECT_REF)
579 recalculate_side_effects (tree t)
581 enum tree_code code = TREE_CODE (t);
582 int fro = first_rtl_op (code);
585 switch (TREE_CODE_CLASS (code))
593 case PREDECREMENT_EXPR:
594 case PREINCREMENT_EXPR:
595 case POSTDECREMENT_EXPR:
596 case POSTINCREMENT_EXPR:
597 /* All of these have side-effects, no matter what their
606 case '<': /* a comparison expression */
607 case '1': /* a unary arithmetic expression */
608 case '2': /* a binary arithmetic expression */
609 case 'r': /* a reference */
610 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
611 for (i = 0; i < fro; ++i)
613 tree op = TREE_OPERAND (t, i);
614 if (op && TREE_SIDE_EFFECTS (op))
615 TREE_SIDE_EFFECTS (t) = 1;