5bfc7db451
Block objects [1] are a C-level syntactic and runtime feature. They are similar to standard C functions, but in addition to executable code they may also contain variable bindings to automatic (stack) or managed (heap) memory. A block can therefore maintain a set of state (data) that it can use to impact behavior when executed. This port is based on Apple's GCC 5646 with some bugfixes from Apple GCC 5666.3. It has some small differences with the support in clang, which remains the recommended compiler. Perhaps the most notable difference is that in GCC that __block is not actually a keyword, but a macro. There will be workaround for this issue in a near future. Other issues can be consulted in the clang documentation [2] For better compatiblity with Apple's GCC and llvm-gcc some related fixes and features from Apple have been included. Support for the non-standard nested functions in GCC is now off by default. No effort was made to update the ObjC support since FreeBSD doesn't carry ObjC in the base system, but some of the code crept in and was more difficult to remove than to adjust. Reference: [1] https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Blocks/Articles/00_Introduction.html [2] http://clang.llvm.org/compatibility.html#block-variable-initialization Obtained from: Apple GCC 4.2 MFC after: 3 weeks
208 lines
7.7 KiB
C
208 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. */
|
|
/* APPLE LOCAL radar 6305545 */
|
|
extern void lower_nested_functions (tree, bool);
|
|
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 */
|