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, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#ifndef _TREE_FLOW_H
#define _TREE_FLOW_H 1
#include "tree-gimple.h"
#include "tree-ssa-operands.h"
#include "cgraph.h"
+#include "ipa-reference.h"
/* Forward declare structures for the garbage collector GTY markers. */
#ifndef GCC_BASIC_BLOCK_H
/* True if the code is in ssa form. */
extern bool in_ssa_p;
+typedef struct
+{
+ htab_t htab;
+ PTR *slot;
+ PTR *limit;
+} htab_iterator;
+
+/* Iterate through the elements of hashtable HTAB, using htab_iterator ITER,
+ storing each element in RESULT, which is of type TYPE. */
+#define FOR_EACH_HTAB_ELEMENT(HTAB, RESULT, TYPE, ITER) \
+ for (RESULT = (TYPE) first_htab_element (&(ITER), (HTAB)); \
+ !end_htab_p (&(ITER)); \
+ RESULT = (TYPE) next_htab_element (&(ITER)))
+
/*---------------------------------------------------------------------------
Attributes for SSA_NAMEs.
is pointing to. */
unsigned int pt_anything : 1;
- /* Nonzero if this pointer is the result of a call to malloc. */
- unsigned int pt_malloc : 1;
-
/* Nonzero if the value of this pointer escapes the current function. */
unsigned int value_escapes_p : 1;
pointer will be represented by this memory tag, instead of the type
tag computed by TBAA. */
tree name_mem_tag;
-};
-
-
-/* Types of value ranges. */
-enum value_range_type { VR_UNDEFINED, VR_RANGE, VR_ANTI_RANGE, VR_VARYING };
-
-
-/* Ranges of values that can be associated with an SSA_NAME after VRP
- has executed. */
-struct value_range_def GTY(())
-{
- /* Lattice value represented by this range. */
- enum value_range_type type;
- /* Minimum and maximum values represented by this range. These
- values are _CST nodes that should be interpreted as follows:
-
- - If TYPE == VR_UNDEFINED then MIN and MAX must be NULL.
-
- - If TYPE == VR_RANGE then MIN holds the minimum value and
- MAX holds the maximum value of the range [MIN, MAX].
-
- - If TYPE == ANTI_RANGE the variable is known to NOT
- take any values in the range [MIN, MAX]. */
- tree min;
- tree max;
+ /* Mask of reasons this pointer's value escapes the function */
+ unsigned int escape_mask;
};
-typedef struct value_range_def value_range;
-
/*---------------------------------------------------------------------------
Tree annotations stored in tree_common.ann
---------------------------------------------------------------------------*/
-enum tree_ann_type { TREE_ANN_COMMON, VAR_ANN, STMT_ANN };
+enum tree_ann_type { TREE_ANN_COMMON, VAR_ANN, FUNCTION_ANN, STMT_ANN };
struct tree_ann_common_d GTY(())
{
/* Annotation type. */
enum tree_ann_type type;
+ /* Auxiliary info specific to a pass. At all times, this
+ should either point to valid data or be NULL. */
+ PTR GTY ((skip (""))) aux;
+
/* The value handle for this expression. Used by GVN-PRE. */
tree GTY((skip)) value_handle;
};
NEED_PHI_STATE_MAYBE
};
-
-/* When computing aliasing information, we represent the memory pointed-to
- by pointers with artificial variables called "memory tags" (MT). There
- are two kinds of tags: type and name. Type tags (TMT) are used in
- type-based alias analysis, they represent all the pointed-to locations
- and variables of the same alias set class. Name tags (NMT) are used in
- flow-sensitive points-to alias analysis, they represent the variables
- and memory locations pointed-to by a specific SSA_NAME pointer. */
-enum mem_tag_kind {
- /* This variable is not a memory tag. */
- NOT_A_TAG,
-
- /* This variable is a type memory tag (TMT). */
- TYPE_TAG,
-
- /* This variable is a name memory tag (NMT). */
- NAME_TAG,
-
- /* This variable represents a structure field. */
- STRUCT_FIELD
-};
struct subvar;
typedef struct subvar *subvar_t;
/* This structure represents a fake sub-variable for a structure field. */
-
struct subvar GTY(())
{
- /* Fake variable name */
+ /* Fake variable. */
tree var;
- /* Offset inside structure. */
- HOST_WIDE_INT offset;
- /* Size of field. */
- HOST_WIDE_INT size;
+
/* Next subvar for this structure. */
subvar_t next;
};
/* Used when building root_var structures in tree_ssa_live.[ch]. */
unsigned root_var_processed : 1;
- /* If nonzero, this variable is a memory tag. */
- ENUM_BITFIELD (mem_tag_kind) mem_tag_kind : 2;
-
- /* Nonzero if this variable is an alias tag that represents references to
- other variables (i.e., this variable appears in the MAY_ALIASES array
- of other variables). */
- unsigned is_alias_tag : 1;
+ /* Nonzero if this variable is in the alias set of another variable. */
+ unsigned is_aliased : 1;
/* Nonzero if this variable was used after SSA optimizations were
applied. We set this when translating out of SSA form. */
unsigned in_v_may_def_list : 1;
/* An artificial variable representing the memory location pointed-to by
- all the pointers that TBAA (type-based alias analysis) considers
- to be aliased. If the variable is not a pointer or if it is never
- dereferenced, this must be NULL. */
- tree type_mem_tag;
+ all the pointer symbols that flow-insensitive alias analysis
+ (mostly type-based) considers to be aliased. If the variable is
+ not a pointer or if it is never dereferenced, this must be NULL. */
+ tree symbol_mem_tag;
/* Variables that may alias this variable. */
- varray_type may_aliases;
-
- /* Unique ID of this variable. */
- size_t uid;
+ VEC(tree, gc) *may_aliases;
/* Used when going out of SSA form to indicate which partition this
variable represents storage for. */
/* Used by the root-var object in tree-ssa-live.[ch]. */
unsigned root_index;
- /* Default definition for this symbol. If this field is not NULL, it
- means that the first reference to this variable in the function is a
- USE or a VUSE. In those cases, the SSA renamer creates an SSA name
- for this variable with an empty defining statement. */
- tree default_def;
-
/* During into-ssa and the dominator optimizer, this field holds the
current version of this variable (an SSA_NAME). */
tree current_def;
/* If this variable is a structure, this fields holds a list of
symbols representing each of the fields of the structure. */
subvar_t subvars;
+
+ /* Mask of values saying the reasons why this variable has escaped
+ the function. */
+ unsigned int escape_mask;
};
+struct function_ann_d GTY(())
+{
+ struct tree_ann_common_d common;
+
+ /* Pointer to the structure that contains the sets of global
+ variables modified by function calls. This field is only used
+ for FUNCTION_DECLs. */
+ ipa_reference_vars_info_t GTY ((skip)) reference_vars_info;
+};
typedef struct immediate_use_iterator_d
{
+ /* This is the current use the iterator is processing. */
ssa_use_operand_t *imm_use;
+ /* This marks the last use in the list (use node from SSA_NAME) */
ssa_use_operand_t *end_p;
+ /* This node is inserted and used to mark the end of the uses for a stmt. */
ssa_use_operand_t iter_node;
+ /* This is the next ssa_name to visit. IMM_USE may get removed before
+ the next one is traversed to, so it must be cached early. */
+ ssa_use_operand_t *next_imm_name;
} imm_use_iterator;
!end_readonly_imm_use_p (&(ITER)); \
(DEST) = next_readonly_imm_use (&(ITER)))
+/* Use this iterator to visit each stmt which has a use of SSAVAR. */
-#define FOR_EACH_IMM_USE_SAFE(DEST, ITER, SSAVAR) \
- for ((DEST) = first_safe_imm_use (&(ITER), (SSAVAR)); \
- !end_safe_imm_use_p (&(ITER)); \
- (DEST) = next_safe_imm_use (&(ITER)))
+#define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \
+ for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \
+ !end_imm_use_stmt_p (&(ITER)); \
+ (STMT) = next_imm_use_stmt (&(ITER)))
-#define BREAK_FROM_SAFE_IMM_USE(ITER) \
+/* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to
+ do so will result in leaving a iterator marker node in the immediate
+ use list, and nothing good will come from that. */
+#define BREAK_FROM_IMM_USE_STMT(ITER) \
{ \
- end_safe_imm_use_traverse (&(ITER)); \
+ end_imm_use_stmt_traverse (&(ITER)); \
break; \
}
+
+/* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to
+ get access to each occurrence of ssavar on the stmt returned by
+ that iterator.. for instance:
+
+ FOR_EACH_IMM_USE_STMT (stmt, iter, var)
+ {
+ FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
+ {
+ SET_USE (use_p) = blah;
+ }
+ update_stmt (stmt);
+ } */
+
+#define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \
+ for ((DEST) = first_imm_use_on_stmt (&(ITER)); \
+ !end_imm_use_on_stmt_p (&(ITER)); \
+ (DEST) = next_imm_use_on_stmt (&(ITER)))
+
+
+
struct stmt_ann_d GTY(())
{
struct tree_ann_common_d common;
need to be scanned again). */
unsigned modified : 1;
- /* Nonzero if the statement makes aliased loads. */
- unsigned makes_aliased_loads : 1;
-
- /* Nonzero if the statement makes aliased stores. */
- unsigned makes_aliased_stores : 1;
-
/* Nonzero if the statement makes references to volatile storage. */
unsigned has_volatile_ops : 1;
unsigned makes_clobbering_call : 1;
/* Basic block that contains this statement. */
- basic_block GTY ((skip (""))) bb;
+ basic_block bb;
/* Operand cache for stmt. */
struct stmt_operands_d GTY ((skip (""))) operands;
pass which needs statement UIDs. */
unsigned int uid;
- /* Auxiliary info specific to a pass. At all times, this
- should either point to valid data or be NULL. */
- PTR GTY ((skip (""))) aux;
-
/* Linked list of histograms for value-based profiling. This is really a
struct histogram_value*. We use void* to avoid having to export that
everywhere, and to avoid having to put it in GC memory. */
union tree_ann_d GTY((desc ("ann_type ((tree_ann_t)&%h)")))
{
struct tree_ann_common_d GTY((tag ("TREE_ANN_COMMON"))) common;
- struct var_ann_d GTY((tag ("VAR_ANN"))) decl;
+ struct var_ann_d GTY((tag ("VAR_ANN"))) vdecl;
+ struct function_ann_d GTY((tag ("FUNCTION_ANN"))) fdecl;
struct stmt_ann_d GTY((tag ("STMT_ANN"))) stmt;
};
typedef union tree_ann_d *tree_ann_t;
typedef struct var_ann_d *var_ann_t;
+typedef struct function_ann_d *function_ann_t;
typedef struct stmt_ann_d *stmt_ann_t;
static inline tree_ann_t tree_ann (tree);
static inline tree_ann_t get_tree_ann (tree);
static inline var_ann_t var_ann (tree);
static inline var_ann_t get_var_ann (tree);
+static inline function_ann_t function_ann (tree);
+static inline function_ann_t get_function_ann (tree);
static inline stmt_ann_t stmt_ann (tree);
static inline stmt_ann_t get_stmt_ann (tree);
static inline enum tree_ann_type ann_type (tree_ann_t);
static inline bool noreturn_call_p (tree);
static inline void update_stmt (tree);
static inline bool stmt_modified_p (tree);
-static inline varray_type may_aliases (tree);
+static inline VEC(tree, gc) *may_aliases (tree);
static inline int get_lineno (tree);
static inline const char *get_filename (tree);
static inline bool is_exec_stmt (tree);
static inline bool is_label_stmt (tree);
static inline bitmap addresses_taken (tree);
-static inline void set_default_def (tree, tree);
-static inline tree default_def (tree);
/*---------------------------------------------------------------------------
Structure representing predictions in tree level.
---------------------------------------------------------------------------*/
-struct edge_prediction GTY((chain_next ("%h.next")))
+struct edge_prediction GTY((chain_next ("%h.ep_next")))
{
- struct edge_prediction *next;
- edge edge;
- enum br_predictor predictor;
- int probability;
+ struct edge_prediction *ep_next;
+ edge ep_edge;
+ enum br_predictor ep_predictor;
+ int ep_probability;
};
+/* Accessors for basic block annotations. */
+static inline tree phi_nodes (basic_block);
+static inline void set_phi_nodes (basic_block, tree);
+
/*---------------------------------------------------------------------------
- Block annotations stored in basic_block.tree_annotations
+ Global declarations
---------------------------------------------------------------------------*/
-struct bb_ann_d GTY(())
+struct int_tree_map GTY(())
{
- /* Chain of PHI nodes for this block. */
- tree phi_nodes;
+
+ unsigned int uid;
+ tree to;
+};
- /* Nonzero if this block contains an escape point (see is_escape_site). */
- unsigned has_escape_site : 1;
+extern unsigned int int_tree_map_hash (const void *);
+extern int int_tree_map_eq (const void *, const void *);
- /* Nonzero if one or more incoming edges to this block should be threaded
- to an outgoing edge of this block. */
- unsigned incoming_edge_threaded : 1;
+typedef struct
+{
+ htab_iterator hti;
+} referenced_var_iterator;
- struct edge_prediction *predictions;
-};
-typedef struct bb_ann_d *bb_ann_t;
+/* This macro loops over all the referenced vars, one at a time, putting the
+ current var in VAR. Note: You are not allowed to add referenced variables
+ to the hashtable while using this macro. Doing so may cause it to behave
+ erratically. */
-/* Accessors for basic block annotations. */
-static inline bb_ann_t bb_ann (basic_block);
-static inline tree phi_nodes (basic_block);
-static inline void set_phi_nodes (basic_block, tree);
+#define FOR_EACH_REFERENCED_VAR(VAR, ITER) \
+ for ((VAR) = first_referenced_var (&(ITER)); \
+ !end_referenced_vars_p (&(ITER)); \
+ (VAR) = next_referenced_var (&(ITER)))
+
+
+typedef struct
+{
+ int i;
+} safe_referenced_var_iterator;
+
+/* This macro loops over all the referenced vars, one at a time, putting the
+ current var in VAR. You are allowed to add referenced variables during the
+ execution of this macro, however, the macro will not iterate over them. It
+ requires a temporary vector of trees, VEC, whose lifetime is controlled by
+ the caller. The purpose of the vector is to temporarily store the
+ referenced_variables hashtable so that adding referenced variables does not
+ affect the hashtable. */
+
+#define FOR_EACH_REFERENCED_VAR_SAFE(VAR, VEC, ITER) \
+ for ((ITER).i = 0, fill_referenced_var_vec (&(VEC)); \
+ VEC_iterate (tree, (VEC), (ITER).i, (VAR)); \
+ (ITER).i++)
-/*---------------------------------------------------------------------------
- Global declarations
----------------------------------------------------------------------------*/
/* Array of all variables referenced in the function. */
-extern GTY(()) VEC(tree,gc) *referenced_vars;
+extern GTY((param_is (struct int_tree_map))) htab_t referenced_vars;
-#define num_referenced_vars VEC_length (tree, referenced_vars)
-#define referenced_var(i) VEC_index (tree, referenced_vars, i)
+/* Default defs for undefined symbols. */
+extern GTY((param_is (struct int_tree_map))) htab_t default_defs;
+
+extern tree referenced_var_lookup (unsigned int);
+#define num_referenced_vars htab_elements (referenced_vars)
+#define referenced_var(i) referenced_var_lookup (i)
/* Array of all SSA_NAMEs used in the function. */
extern GTY(()) VEC(tree,gc) *ssa_names;
static inline tree bsi_stmt (block_stmt_iterator);
static inline tree * bsi_stmt_ptr (block_stmt_iterator);
-extern void bsi_remove (block_stmt_iterator *);
+extern void bsi_remove (block_stmt_iterator *, bool);
extern void bsi_move_before (block_stmt_iterator *, block_stmt_iterator *);
extern void bsi_move_after (block_stmt_iterator *, block_stmt_iterator *);
extern void bsi_move_to_bb_end (block_stmt_iterator *, basic_block);
extern void bsi_replace (const block_stmt_iterator *, tree, bool);
/*---------------------------------------------------------------------------
+ OpenMP Region Tree
+---------------------------------------------------------------------------*/
+
+/* Parallel region information. Every parallel and workshare
+ directive is enclosed between two markers, the OMP_* directive
+ and a corresponding OMP_RETURN statement. */
+
+struct omp_region
+{
+ /* The enclosing region. */
+ struct omp_region *outer;
+
+ /* First child region. */
+ struct omp_region *inner;
+
+ /* Next peer region. */
+ struct omp_region *next;
+
+ /* Block containing the omp directive as its last stmt. */
+ basic_block entry;
+
+ /* Block containing the OMP_RETURN as its last stmt. */
+ basic_block exit;
+
+ /* Block containing the OMP_CONTINUE as its last stmt. */
+ basic_block cont;
+
+ /* If this is a combined parallel+workshare region, this is a list
+ of additional arguments needed by the combined parallel+workshare
+ library call. */
+ tree ws_args;
+
+ /* The code for the omp directive of this region. */
+ enum tree_code type;
+
+ /* Schedule kind, only used for OMP_FOR type regions. */
+ enum omp_clause_schedule_kind sched_kind;
+
+ /* True if this is a combined parallel+workshare region. */
+ bool is_combined_parallel;
+};
+
+extern struct omp_region *root_omp_region;
+extern struct omp_region *new_omp_region (basic_block, enum tree_code,
+ struct omp_region *);
+extern void free_omp_regions (void);
+
+/*---------------------------------------------------------------------------
Function prototypes
---------------------------------------------------------------------------*/
/* In tree-cfg.c */
extern bool is_ctrl_altering_stmt (tree);
extern bool computed_goto_p (tree);
extern bool simple_goto_p (tree);
+extern basic_block single_noncomplex_succ (basic_block bb);
extern void tree_dump_bb (basic_block, FILE *, int);
extern void debug_tree_bb (basic_block);
extern basic_block debug_tree_bb_n (int);
extern void print_loop_ir (FILE *);
extern void cleanup_dead_labels (void);
extern void group_case_labels (void);
-extern bool cleanup_tree_cfg (void);
-extern void cleanup_tree_cfg_loop (void);
extern tree first_stmt (basic_block);
extern tree last_stmt (basic_block);
extern tree *last_stmt_ptr (basic_block);
extern tree gimplify_build3 (block_stmt_iterator *, enum tree_code,
tree, tree, tree, tree);
extern void init_empty_tree_cfg (void);
+extern void fold_cond_expr_cond (void);
+extern void replace_uses_by (tree, tree);
+extern void start_recording_case_labels (void);
+extern void end_recording_case_labels (void);
+extern basic_block move_sese_region_to_fn (struct function *, basic_block,
+ basic_block);
+
+/* In tree-cfgcleanup.c */
+extern bool cleanup_tree_cfg (void);
+extern void cleanup_tree_cfg_loop (void);
/* In tree-pretty-print.c. */
extern void dump_generic_bb (FILE *, basic_block, int, int);
/* In tree-dfa.c */
extern var_ann_t create_var_ann (tree);
+extern function_ann_t create_function_ann (tree);
extern stmt_ann_t create_stmt_ann (tree);
extern tree_ann_t create_tree_ann (tree);
-extern void reserve_phi_args_for_new_edge (basic_block);
-extern tree create_phi_node (tree, basic_block);
-extern void add_phi_arg (tree, tree, edge);
-extern void remove_phi_args (edge);
-extern void remove_phi_node (tree, tree);
-extern tree phi_reverse (tree);
extern void dump_dfa_stats (FILE *);
extern void debug_dfa_stats (void);
extern void debug_referenced_vars (void);
extern void dump_referenced_vars (FILE *);
extern void dump_variable (FILE *, tree);
extern void debug_variable (tree);
+extern void dump_subvars_for (FILE *, tree);
+extern void debug_subvars_for (tree);
extern tree get_virtual_var (tree);
-extern void add_referenced_tmp_var (tree);
+extern void add_referenced_var (tree);
extern void mark_new_vars_to_rename (tree);
extern void find_new_referenced_vars (tree *);
extern tree make_rename_temp (tree, const char *);
+extern void set_default_def (tree, tree);
+extern tree default_def (tree);
+extern tree default_def_fn (struct function *, tree);
+
+/* In tree-phinodes.c */
+extern void reserve_phi_args_for_new_edge (basic_block);
+extern tree create_phi_node (tree, basic_block);
+extern void add_phi_arg (tree, tree, edge);
+extern void remove_phi_args (edge);
+extern void remove_phi_node (tree, tree);
+extern tree phi_reverse (tree);
/* In gimple-low.c */
+extern void record_vars_into (tree, tree);
extern void record_vars (tree);
-extern bool block_may_fallthru (tree block);
+extern bool block_may_fallthru (tree);
/* In tree-ssa-alias.c */
extern void dump_may_aliases_for (FILE *, tree);
extern void dump_points_to_info_for (FILE *, tree);
extern void debug_points_to_info_for (tree);
extern bool may_be_aliased (tree);
+extern bool is_aliased_with (tree, tree);
extern struct ptr_info_def *get_ptr_info (tree);
-extern void add_type_alias (tree, tree);
+extern void new_type_alias (tree, tree, tree);
extern void count_uses_and_derefs (tree, tree, unsigned *, unsigned *, bool *);
static inline subvar_t get_subvars_for_var (tree);
+static inline tree get_subvar_at (tree, unsigned HOST_WIDE_INT);
static inline bool ref_contains_array_ref (tree);
-extern tree okay_component_ref_for_subvars (tree, HOST_WIDE_INT *,
- HOST_WIDE_INT *);
+static inline bool array_ref_contains_indirect_ref (tree);
+extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *,
+ HOST_WIDE_INT *, HOST_WIDE_INT *);
static inline bool var_can_have_subvars (tree);
-static inline bool overlap_subvar (HOST_WIDE_INT, HOST_WIDE_INT,
- subvar_t, bool *);
+static inline bool overlap_subvar (unsigned HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT,
+ tree, bool *);
/* Call-back function for walk_use_def_chains(). At each reaching
definition, a function with this prototype is called. */
/* In tree-ssa-ccp.c */
bool fold_stmt (tree *);
+bool fold_stmt_inplace (tree);
tree widen_bitfield (tree, tree, tree);
/* In tree-vrp.c */
-value_range *get_value_range (tree);
-void dump_value_range (FILE *, value_range *);
-void debug_value_range (value_range *);
-void dump_all_value_ranges (FILE *);
-void debug_all_value_ranges (void);
-bool expr_computes_nonzero (tree);
+tree vrp_evaluate_conditional (tree, bool);
+void simplify_stmt_using_ranges (tree);
/* In tree-ssa-dom.c */
extern void dump_dominator_optimization_stats (FILE *);
int loop_depth_of_name (tree);
/* In tree-ssa-copy.c */
+extern void merge_alias_info (tree, tree);
extern void propagate_value (use_operand_p, tree);
extern void propagate_tree_value (tree *, tree);
extern void replace_exp (use_operand_p, tree);
extern bool may_propagate_copy (tree, tree);
extern bool may_propagate_copy_into_asm (tree);
+/* Affine iv. */
+
+typedef struct
+{
+ /* Iv = BASE + STEP * i. */
+ tree base, step;
+
+ /* True if this iv does not overflow. */
+ bool no_overflow;
+} affine_iv;
+
/* Description of number of iterations of a loop. All the expressions inside
the structure can be evaluated at the end of the loop's preheader
(and due to ssa form, also anywhere inside the body of the loop). */
MAX_SIGNED_INT. However if the (n <= 0) assumption
is eliminated (by looking at the guard on entry of
the loop), then the information would be lost. */
+
+ /* The simplified shape of the exit condition. The loop exits if
+ CONTROL CMP BOUND is false, where CMP is one of NE_EXPR,
+ LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is
+ LE_EXPR and negative if CMP is GE_EXPR. This information is used
+ by loop unrolling. */
+ affine_iv control;
+ tree bound;
+ enum tree_code cmp;
};
/* In tree-vectorizer.c */
void vectorize_loops (struct loops *);
+extern bool vect_can_force_dr_alignment_p (tree, unsigned int);
+extern tree get_vectype_for_scalar_type (tree);
/* In tree-ssa-phiopt.c */
bool empty_block_p (basic_block);
/* In tree-ssa-loop*.c */
void tree_ssa_lim (struct loops *);
-void tree_ssa_unswitch_loops (struct loops *);
-void canonicalize_induction_variables (struct loops *);
-void tree_unroll_loops_completely (struct loops *, bool);
+unsigned int tree_ssa_unswitch_loops (struct loops *);
+unsigned int canonicalize_induction_variables (struct loops *);
+unsigned int tree_unroll_loops_completely (struct loops *, bool);
+unsigned int tree_ssa_prefetch_arrays (struct loops *);
+unsigned int remove_empty_loops (struct loops *);
void tree_ssa_iv_optimize (struct loops *);
bool number_of_iterations_exit (struct loop *, edge,
- struct tree_niter_desc *niter);
+ struct tree_niter_desc *niter, bool);
tree find_loop_niter (struct loop *, edge *);
tree loop_niter_by_eval (struct loop *, edge);
tree find_loop_niter_by_eval (struct loop *, edge *);
void estimate_numbers_of_iterations (struct loops *);
-tree can_count_iv_in_wider_type (struct loop *, tree, tree, tree, tree);
+bool scev_probably_wraps_p (tree, tree, tree, struct loop *, bool);
+bool convert_affine_scev (struct loop *, tree, tree *, tree *, tree, bool);
+
+bool nowrap_type_p (tree);
+enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN};
+enum ev_direction scev_direction (tree);
+
void free_numbers_of_iterations_estimates (struct loops *);
+void free_numbers_of_iterations_estimates_loop (struct loop *);
void rewrite_into_loop_closed_ssa (bitmap, unsigned);
void verify_loop_closed_ssa (void);
void loop_commit_inserts (void);
void create_iv (tree, tree, tree, struct loop *, block_stmt_iterator *, bool,
tree *, tree *);
void split_loop_exit_edge (edge);
+unsigned force_expr_to_var_cost (tree);
basic_block bsi_insert_on_edge_immediate_loop (edge, tree);
void standard_iv_increment_position (struct loop *, block_stmt_iterator *,
bool *);
unsigned int *, int);
struct loop *tree_ssa_loop_version (struct loops *, struct loop *, tree,
basic_block *);
+tree expand_simple_operations (tree);
+void substitute_in_loop_info (struct loop *, tree, tree);
+edge single_dom_exit (struct loop *);
+bool can_unroll_loop_p (struct loop *loop, unsigned factor,
+ struct tree_niter_desc *niter);
+void tree_unroll_loop (struct loops *, struct loop *, unsigned,
+ edge, struct tree_niter_desc *);
+bool contains_abnormal_ssa_name_p (tree);
+
+/* In tree-ssa-threadedge.c */
+extern bool potentially_threadable_block (basic_block);
+extern void thread_across_edge (tree, edge, bool,
+ VEC(tree, heap) **, tree (*) (tree));
/* In tree-ssa-loop-im.c */
/* The possibilities of statement movement. */
};
extern enum move_pos movement_possibility (tree);
+/* The reasons a variable may escape a function. */
+enum escape_type
+ {
+ NO_ESCAPE = 0, /* Doesn't escape. */
+ ESCAPE_STORED_IN_GLOBAL = 1 << 1,
+ ESCAPE_TO_ASM = 1 << 2, /* Passed by address to an assembly
+ statement. */
+ ESCAPE_TO_CALL = 1 << 3, /* Escapes to a function call. */
+ ESCAPE_BAD_CAST = 1 << 4, /* Cast from pointer to integer */
+ ESCAPE_TO_RETURN = 1 << 5, /* Returned from function. */
+ ESCAPE_TO_PURE_CONST = 1 << 6, /* Escapes to a pure or constant
+ function call. */
+ ESCAPE_IS_GLOBAL = 1 << 7, /* Is a global variable. */
+ ESCAPE_IS_PARM = 1 << 8, /* Is an incoming function parameter. */
+ ESCAPE_UNKNOWN = 1 << 9 /* We believe it escapes for some reason
+ not enumerated above. */
+ };
+
/* In tree-flow-inline.h */
static inline bool is_call_clobbered (tree);
-static inline void mark_call_clobbered (tree);
+static inline void mark_call_clobbered (tree, unsigned int);
static inline void set_is_used (tree);
static inline bool unmodifiable_var_p (tree);
/* In tree-vn.c */
bool expressions_equal_p (tree, tree);
tree get_value_handle (tree);
-hashval_t vn_compute (tree, hashval_t, tree);
+hashval_t vn_compute (tree, hashval_t);
+void sort_vuses (VEC (tree, gc) *);
tree vn_lookup_or_add (tree, tree);
-void vn_add (tree, tree, tree);
+tree vn_lookup_or_add_with_vuses (tree, VEC (tree, gc) *);
+void vn_add (tree, tree);
+void vn_add_with_vuses (tree, tree, VEC (tree, gc) *);
tree vn_lookup (tree, tree);
+tree vn_lookup_with_vuses (tree, VEC (tree, gc) *);
void vn_init (void);
void vn_delete (void);
/* In tree-sra.c */
void insert_edge_copies (tree, basic_block);
+void sra_insert_before (block_stmt_iterator *, tree);
+void sra_insert_after (block_stmt_iterator *, tree);
+void sra_init_cache (void);
+bool sra_type_can_be_decomposed_p (tree);
/* In tree-loop-linear.c */
extern void linear_transform_loops (struct loops *);
/* In tree-ssa-loop-ivopts.c */
-extern bool expr_invariant_in_loop_p (struct loop *, tree);
+bool expr_invariant_in_loop_p (struct loop *, tree);
+bool multiplier_allowed_in_address_p (HOST_WIDE_INT);
+unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode);
+
+/* In tree-ssa-threadupdate.c. */
+extern bool thread_through_all_blocks (void);
+extern void register_jump_thread (edge, edge);
/* In gimplify.c */
tree force_gimple_operand (tree, tree *, bool, tree);
tree force_gimple_operand_bsi (block_stmt_iterator *, tree, bool, tree);
+/* In tree-ssa-structalias.c */
+bool find_what_p_points_to (tree);
+
+/* In tree-ssa-live.c */
+extern void remove_unused_locals (void);
+
+/* In tree-ssa-address.c */
+
+/* Affine combination of trees. We keep track of at most MAX_AFF_ELTS elements
+ to make things simpler; this is sufficient in most cases. */
+
+#define MAX_AFF_ELTS 8
+
+struct affine_tree_combination
+{
+ /* Type of the result of the combination. */
+ tree type;
+
+ /* Mask modulo that the operations are performed. */
+ unsigned HOST_WIDE_INT mask;
+
+ /* Constant offset. */
+ unsigned HOST_WIDE_INT offset;
+
+ /* Number of elements of the combination. */
+ unsigned n;
+
+ /* Elements and their coefficients. */
+ tree elts[MAX_AFF_ELTS];
+ unsigned HOST_WIDE_INT coefs[MAX_AFF_ELTS];
+
+ /* Remainder of the expression. */
+ tree rest;
+};
+
+/* Description of a memory address. */
+
+struct mem_address
+{
+ tree symbol, base, index, step, offset;
+};
+
+tree create_mem_ref (block_stmt_iterator *, tree,
+ struct affine_tree_combination *);
+rtx addr_for_mem_ref (struct mem_address *, bool);
+void get_address_description (tree, struct mem_address *);
+tree maybe_fold_tmr (tree);
+
+/* This structure is simply used during pushing fields onto the fieldstack
+ to track the offset of the field, since bitpos_of_field gives it relative
+ to its immediate containing type, and we want it relative to the ultimate
+ containing object. */
+
+struct fieldoff
+{
+ tree type;
+ tree size;
+ tree decl;
+ HOST_WIDE_INT offset;
+};
+typedef struct fieldoff fieldoff_s;
+
+DEF_VEC_O(fieldoff_s);
+DEF_VEC_ALLOC_O(fieldoff_s,heap);
+int push_fields_onto_fieldstack (tree, VEC(fieldoff_s,heap) **,
+ HOST_WIDE_INT, bool *);
+void sort_fieldstack (VEC(fieldoff_s,heap) *);
+
+void init_alias_heapvars (void);
+void delete_alias_heapvars (void);
+
#include "tree-flow-inline.h"
+void swap_tree_operands (tree, tree *, tree *);
+
+extern void recalculate_used_alone (void);
+extern bool updating_used_alone;
#endif /* _TREE_FLOW_H */
OSDN Git Service
