gcc/tree-gimple.h

   1 /* Functions to analyze and validate GIMPLE trees.
   2    Copyright (C) 2002, 2003 Free Software Foundation, Inc.
   3    Contributed by Diego Novillo <dnovillo@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #ifndef _TREE_SIMPLE_H
  23 #define _TREE_SIMPLE_H 1
  24
  25
  26 #include "tree-iterator.h"
  27
  28 extern tree create_tmp_var_raw (tree, const char *);
  29 extern tree create_tmp_var_name (const char *);
  30 extern tree create_tmp_var (tree, const char *);
  31 extern tree get_initialized_tmp_var (tree, tree *, tree *);
  32 extern tree get_formal_tmp_var (tree, tree *);
  33 extern void declare_tmp_vars (tree, tree);
  34
  35 extern void annotate_all_with_locus (tree *, location_t);
  36
  37 /* Validation of GIMPLE expressions.  Note that these predicates only check
  38    the basic form of the expression, they don't recurse to make sure that
  39    underlying nodes are also of the right form.  */
  40
  41 typedef bool (*gimple_predicate)(tree);
  42
  43 /* Returns true iff T is a valid GIMPLE statement.  */
  44 extern bool is_gimple_stmt (tree);
  45
  46 /* Returns true iff TYPE is a valid type for a scalar register variable.  */
  47 extern bool is_gimple_reg_type (tree);
  48 /* Returns true iff T is a scalar register variable.  */
  49 extern bool is_gimple_reg (tree);
  50 /* Returns true if T is a GIMPLE temporary variable, false otherwise.  */
  51 extern bool is_gimple_tmp_var (tree);
  52 /* Returns true if T is a GIMPLE temporary register variable.  */
  53 extern bool is_gimple_tmp_reg (tree);
  54 /* Returns true iff T is any sort of variable.  */
  55 extern bool is_gimple_variable (tree);
  56 /* Returns true iff T is a variable or an INDIRECT_REF (of a variable).  */
  57 extern bool is_gimple_min_lval (tree);
  58 /* Returns true iff T is an lvalue other than an INDIRECT_REF.  */
  59 extern bool is_gimple_addr_expr_arg (tree);
  60 /* Returns true iff T is any valid GIMPLE lvalue.  */
  61 extern bool is_gimple_lvalue (tree);
  62
  63 /* Returns true iff T is a GIMPLE restricted function invariant.  */
  64 extern bool is_gimple_min_invariant (tree);
  65 /* Returns true iff T is a GIMPLE rvalue.  */
  66 extern bool is_gimple_val (tree);
  67 /* Returns true iff T is a valid rhs for a MODIFY_EXPR where the LHS is a
  68    GIMPLE temporary, a renamed user variable, or something else,
  69    respectively.  */
  70 extern bool is_gimple_tmp_rhs (tree);
  71 extern bool is_gimple_reg_rhs (tree);
  72 extern bool is_gimple_mem_rhs (tree);
  73 /* Returns the appropriate one of the above three predicates for the LHS
  74    T.  */
  75 extern gimple_predicate rhs_predicate_for (tree);
  76
  77 /* Returns true iff T is a valid if-statement condition.  */
  78 extern bool is_gimple_condexpr (tree);
  79
  80 /* Returns true iff T is a type conversion.  */
  81 extern bool is_gimple_cast (tree);
  82 /* Returns true iff T is a valid CONSTRUCTOR element (either an rvalue or
  83    another CONSTRUCTOR).  */
  84 extern bool is_gimple_constructor_elt (tree);
  85 /* Returns true iff T is a variable that does not need to live in memory.  */
  86 extern bool is_gimple_non_addressable (tree t);
  87
  88 /* Returns true iff T is a valid call address expression.  */
  89 extern bool is_gimple_call_addr (tree);
  90 /* If T makes a function call, returns the CALL_EXPR operand.  */
  91 extern tree get_call_expr_in (tree t);
  92
  93 extern void recalculate_side_effects (tree);
  94
  95 /* FIXME we should deduce this from the predicate.  */
  96 typedef enum fallback_t {
  97   fb_none = 0,
  98   fb_rvalue = 1,
  99   fb_lvalue = 2,
 100   fb_mayfail = 4,
 101   fb_either= fb_rvalue | fb_lvalue
 102 } fallback_t;
 103
 104 enum gimplify_status {
 105   GS_ERROR      = -2,   /* Something Bad Seen.  */
 106   GS_UNHANDLED  = -1,   /* A langhook result for "I dunno".  */
 107   GS_OK         = 0,    /* We did something, maybe more to do.  */
 108   GS_ALL_DONE   = 1     /* The expression is fully gimplified.  */
 109 };
 110
 111 extern enum gimplify_status gimplify_expr (tree *, tree *, tree *,
 112                                            bool (*) (tree), fallback_t);
 113 extern void gimplify_type_sizes (tree, tree *);
 114 extern void gimplify_one_sizepos (tree *, tree *);
 115 extern void gimplify_stmt (tree *);
 116 extern void gimplify_to_stmt_list (tree *);
 117 extern void gimplify_body (tree *, tree);
 118 extern void push_gimplify_context (void);
 119 extern void pop_gimplify_context (tree);
 120 extern void gimplify_and_add (tree, tree *);
 121
 122 /* Miscellaneous helpers.  */
 123 extern tree get_base_address (tree t);
 124 extern void gimple_add_tmp_var (tree);
 125 extern tree gimple_current_bind_expr (void);
 126 extern void gimple_push_bind_expr (tree);
 127 extern void gimple_pop_bind_expr (void);
 128 extern void unshare_all_trees (tree);
 129 extern tree voidify_wrapper_expr (tree, tree);
 130 extern tree gimple_build_eh_filter (tree, tree, tree);
 131 extern tree build_and_jump (tree *);
 132 extern tree alloc_stmt_list (void);
 133 extern void free_stmt_list (tree);
 134 extern tree force_labels_r (tree *, int *, void *);
 135 extern enum gimplify_status gimplify_va_arg_expr (tree *, tree *, tree *);
 136
 137 /* In tree-nested.c.  */
 138 extern void lower_nested_functions (tree);
 139
 140 #endif /* _TREE_SIMPLE_H  */