207 lines
7.7 KiB
C
207 lines
7.7 KiB
C
/* Functions to analyze and validate GIMPLE trees.
|
|
Copyright (C) 2002, 2003, 2005 Free Software Foundation, Inc.
|
|
Contributed by Diego Novillo <dnovillo@redhat.com>
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GCC is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
|
|
Boston, MA 02110-1301, USA. */
|
|
|
|
#ifndef _TREE_SIMPLE_H
|
|
#define _TREE_SIMPLE_H 1
|
|
|
|
|
|
#include "tree-iterator.h"
|
|
|
|
extern tree create_tmp_var_raw (tree, const char *);
|
|
extern tree create_tmp_var_name (const char *);
|
|
extern tree create_tmp_var (tree, const char *);
|
|
extern tree get_initialized_tmp_var (tree, tree *, tree *);
|
|
extern tree get_formal_tmp_var (tree, tree *);
|
|
|
|
extern void declare_vars (tree, tree, bool);
|
|
|
|
extern void annotate_all_with_locus (tree *, location_t);
|
|
|
|
/* Validation of GIMPLE expressions. Note that these predicates only check
|
|
the basic form of the expression, they don't recurse to make sure that
|
|
underlying nodes are also of the right form. */
|
|
|
|
typedef bool (*gimple_predicate)(tree);
|
|
|
|
/* Returns true iff T is a valid GIMPLE statement. */
|
|
extern bool is_gimple_stmt (tree);
|
|
|
|
/* Returns true iff TYPE is a valid type for a scalar register variable. */
|
|
extern bool is_gimple_reg_type (tree);
|
|
/* Returns true iff T is a scalar register variable. */
|
|
extern bool is_gimple_reg (tree);
|
|
/* Returns true if T is a GIMPLE temporary variable, false otherwise. */
|
|
extern bool is_gimple_formal_tmp_var (tree);
|
|
/* Returns true if T is a GIMPLE temporary register variable. */
|
|
extern bool is_gimple_formal_tmp_reg (tree);
|
|
/* Returns true iff T is any sort of variable. */
|
|
extern bool is_gimple_variable (tree);
|
|
/* Returns true iff T is any sort of symbol. */
|
|
extern bool is_gimple_id (tree);
|
|
/* Returns true iff T is a variable or an INDIRECT_REF (of a variable). */
|
|
extern bool is_gimple_min_lval (tree);
|
|
/* Returns true iff T is something whose address can be taken. */
|
|
extern bool is_gimple_addressable (tree);
|
|
/* Returns true iff T is any valid GIMPLE lvalue. */
|
|
extern bool is_gimple_lvalue (tree);
|
|
|
|
/* Returns true iff T is a GIMPLE restricted function invariant. */
|
|
extern bool is_gimple_min_invariant (tree);
|
|
/* Returns true iff T is a GIMPLE rvalue. */
|
|
extern bool is_gimple_val (tree);
|
|
/* Returns true iff T is a GIMPLE asm statement input. */
|
|
extern bool is_gimple_asm_val (tree);
|
|
/* Returns true iff T is a valid rhs for a MODIFY_EXPR where the LHS is a
|
|
GIMPLE temporary, a renamed user variable, or something else,
|
|
respectively. */
|
|
extern bool is_gimple_formal_tmp_rhs (tree);
|
|
extern bool is_gimple_reg_rhs (tree);
|
|
extern bool is_gimple_mem_rhs (tree);
|
|
/* Returns the appropriate one of the above three predicates for the LHS
|
|
T. */
|
|
extern gimple_predicate rhs_predicate_for (tree);
|
|
|
|
/* Returns true iff T is a valid if-statement condition. */
|
|
extern bool is_gimple_condexpr (tree);
|
|
|
|
/* Returns true iff T is a type conversion. */
|
|
extern bool is_gimple_cast (tree);
|
|
/* Returns true iff T is a variable that does not need to live in memory. */
|
|
extern bool is_gimple_non_addressable (tree t);
|
|
|
|
/* Returns true iff T is a valid call address expression. */
|
|
extern bool is_gimple_call_addr (tree);
|
|
/* If T makes a function call, returns the CALL_EXPR operand. */
|
|
extern tree get_call_expr_in (tree t);
|
|
|
|
extern void recalculate_side_effects (tree);
|
|
|
|
/* FIXME we should deduce this from the predicate. */
|
|
typedef enum fallback_t {
|
|
fb_none = 0,
|
|
fb_rvalue = 1,
|
|
fb_lvalue = 2,
|
|
fb_mayfail = 4,
|
|
fb_either= fb_rvalue | fb_lvalue
|
|
} fallback_t;
|
|
|
|
enum gimplify_status {
|
|
GS_ERROR = -2, /* Something Bad Seen. */
|
|
GS_UNHANDLED = -1, /* A langhook result for "I dunno". */
|
|
GS_OK = 0, /* We did something, maybe more to do. */
|
|
GS_ALL_DONE = 1 /* The expression is fully gimplified. */
|
|
};
|
|
|
|
extern enum gimplify_status gimplify_expr (tree *, tree *, tree *,
|
|
bool (*) (tree), fallback_t);
|
|
extern void gimplify_type_sizes (tree, tree *);
|
|
extern void gimplify_one_sizepos (tree *, tree *);
|
|
extern void gimplify_stmt (tree *);
|
|
extern void gimplify_to_stmt_list (tree *);
|
|
extern void gimplify_body (tree *, tree, bool);
|
|
extern void push_gimplify_context (void);
|
|
extern void pop_gimplify_context (tree);
|
|
extern void gimplify_and_add (tree, tree *);
|
|
|
|
/* Miscellaneous helpers. */
|
|
extern void gimple_add_tmp_var (tree);
|
|
extern tree gimple_current_bind_expr (void);
|
|
extern tree voidify_wrapper_expr (tree, tree);
|
|
extern tree gimple_build_eh_filter (tree, tree, tree);
|
|
extern tree build_and_jump (tree *);
|
|
extern tree alloc_stmt_list (void);
|
|
extern void free_stmt_list (tree);
|
|
extern tree force_labels_r (tree *, int *, void *);
|
|
extern enum gimplify_status gimplify_va_arg_expr (tree *, tree *, tree *);
|
|
struct gimplify_omp_ctx;
|
|
extern void omp_firstprivatize_variable (struct gimplify_omp_ctx *, tree);
|
|
extern tree gimple_boolify (tree);
|
|
|
|
/* In omp-low.c. */
|
|
extern void diagnose_omp_structured_block_errors (tree);
|
|
extern tree omp_reduction_init (tree, tree);
|
|
|
|
/* In tree-nested.c. */
|
|
extern void lower_nested_functions (tree);
|
|
extern void insert_field_into_struct (tree, tree);
|
|
|
|
/* Convenience routines to walk all statements of a gimple function.
|
|
The difference between these walkers and the generic walk_tree is
|
|
that walk_stmt provides context information to the callback
|
|
routine to know whether it is currently on the LHS or RHS of an
|
|
assignment (IS_LHS) or contexts where only GIMPLE values are
|
|
allowed (VAL_ONLY).
|
|
|
|
This is useful in walkers that need to re-write sub-expressions
|
|
inside statements while making sure the result is still in GIMPLE
|
|
form.
|
|
|
|
Note that this is useful exclusively before the code is converted
|
|
into SSA form. Once the program is in SSA form, the standard
|
|
operand interface should be used to analyze/modify statements. */
|
|
|
|
struct walk_stmt_info
|
|
{
|
|
/* For each statement, we invoke CALLBACK via walk_tree. The passed
|
|
data is a walk_stmt_info structure. */
|
|
walk_tree_fn callback;
|
|
|
|
/* Points to the current statement being walked. */
|
|
tree_stmt_iterator tsi;
|
|
|
|
/* Additional data that CALLBACK may want to carry through the
|
|
recursion. */
|
|
void *info;
|
|
|
|
/* Indicates whether the *TP being examined may be replaced
|
|
with something that matches is_gimple_val (if true) or something
|
|
slightly more complicated (if false). "Something" technically
|
|
means the common subset of is_gimple_lvalue and is_gimple_rhs,
|
|
but we never try to form anything more complicated than that, so
|
|
we don't bother checking.
|
|
|
|
Also note that CALLBACK should update this flag while walking the
|
|
sub-expressions of a statement. For instance, when walking the
|
|
statement 'foo (&var)', the flag VAL_ONLY will initially be set
|
|
to true, however, when walking &var, the operand of that
|
|
ADDR_EXPR does not need to be a GIMPLE value. */
|
|
bool val_only;
|
|
|
|
/* True if we are currently walking the LHS of an assignment. */
|
|
bool is_lhs;
|
|
|
|
/* Optional. Set to true by CALLBACK if it made any changes. */
|
|
bool changed;
|
|
|
|
/* True if we're interested in seeing BIND_EXPRs. */
|
|
bool want_bind_expr;
|
|
|
|
/* True if we're interested in seeing RETURN_EXPRs. */
|
|
bool want_return_expr;
|
|
|
|
/* True if we're interested in location information. */
|
|
bool want_locations;
|
|
};
|
|
|
|
void walk_stmts (struct walk_stmt_info *, tree *);
|
|
|
|
#endif /* _TREE_SIMPLE_H */
|