typedef struct basic_block_def *basic_block;
#endif
-/* True if the code is in ssa form. */
-extern bool in_ssa_p;
+/* Gimple dataflow datastructure. All publicly available fields shall have
+ gimple_ accessor defined in tree-flow-inline.h, all publicly modifiable
+ fields should have gimple_set accessor. */
+struct gimple_df GTY(()) {
+ /* Array of all variables referenced in the function. */
+ htab_t GTY((param_is (struct int_tree_map))) referenced_vars;
+ /* A list of all the noreturn calls passed to modify_stmt.
+ cleanup_control_flow uses it to detect cases where a mid-block
+ indirect call has been turned into a noreturn call. When this
+ happens, all the instructions after the call are no longer
+ reachable and must be deleted as dead. */
+ VEC(tree,gc) *modified_noreturn_calls;
+ /* Array of all SSA_NAMEs used in the function. */
+ VEC(tree,gc) *ssa_names;
+
+ /* Artificial variable used to model the effects of function calls. */
+ tree global_var;
+
+ /* Artificial variable used to model the effects of nonlocal
+ variables. */
+ tree nonlocal_all;
+
+ /* Call clobbered variables in the function. If bit I is set, then
+ REFERENCED_VARS (I) is call-clobbered. */
+ bitmap call_clobbered_vars;
+
+ /* Addressable variables in the function. If bit I is set, then
+ REFERENCED_VARS (I) has had its address taken. Note that
+ CALL_CLOBBERED_VARS and ADDRESSABLE_VARS are not related. An
+ addressable variable is not necessarily call-clobbered (e.g., a
+ local addressable whose address does not escape) and not all
+ call-clobbered variables are addressable (e.g., a local static
+ variable). */
+ bitmap addressable_vars;
+
+ /* Free list of SSA_NAMEs. */
+ tree free_ssanames;
+
+ /* Hashtable holding definition for 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. */
+ htab_t GTY((param_is (struct int_tree_map))) default_defs;
+
+ /* 'true' after aliases have been computed (see compute_may_aliases). */
+ unsigned int aliases_computed_p : 1;
+
+ /* True if the code is in ssa form. */
+ unsigned int in_ssa_p : 1;
+
+ struct ssa_operands ssa_operands;
+};
+
+/* Accessors for internal use only. Generic code should use abstraction
+ provided by tree-flow-inline.h or specific modules. */
+#define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames
+#define SSANAMES(fun) (fun)->gimple_df->ssa_names
+#define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls
+#define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs
typedef struct
{
/*---------------------------------------------------------------------------
- Tree annotations stored in tree_common.ann
+ Tree annotations stored in tree_base.ann
---------------------------------------------------------------------------*/
enum tree_ann_type { TREE_ANN_COMMON, VAR_ANN, FUNCTION_ANN, STMT_ANN };
/* 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;
struct stmt_ann_d GTY((tag ("STMT_ANN"))) stmt;
};
-extern GTY(()) VEC(tree,gc) *modified_noreturn_calls;
-
typedef union tree_ann_d *tree_ann_t;
typedef struct var_ann_d *var_ann_t;
typedef struct function_ann_d *function_ann_t;
VEC_iterate (tree, (VEC), (ITER).i, (VAR)); \
(ITER).i++)
-/* Array of all variables referenced in the function. */
-extern GTY((param_is (struct int_tree_map))) htab_t referenced_vars;
-
-/* Default defs for undefined symbols. */
-extern GTY((param_is (struct int_tree_map))) htab_t default_defs;
-
extern tree referenced_var_lookup (unsigned int);
extern bool referenced_var_check_and_insert (tree);
-#define num_referenced_vars htab_elements (referenced_vars)
+#define num_referenced_vars htab_elements (gimple_referenced_vars (cfun))
#define referenced_var(i) referenced_var_lookup (i)
-/* Array of all SSA_NAMEs used in the function. */
-extern GTY(()) VEC(tree,gc) *ssa_names;
-
-#define num_ssa_names (VEC_length (tree, ssa_names))
-#define ssa_name(i) (VEC_index (tree, ssa_names, (i)))
-
-/* Artificial variable used to model the effects of function calls. */
-extern GTY(()) tree global_var;
-
-/* Artificial variable used to model the effects of nonlocal
- variables. */
-extern GTY(()) tree nonlocal_all;
-
-/* Call clobbered variables in the function. If bit I is set, then
- REFERENCED_VARS (I) is call-clobbered. */
-extern bitmap call_clobbered_vars;
-
-/* Addressable variables in the function. If bit I is set, then
- REFERENCED_VARS (I) has had its address taken. */
-extern bitmap addressable_vars;
-
-/* 'true' after aliases have been computed (see compute_may_aliases). */
-extern bool aliases_computed_p;
+#define num_ssa_names (VEC_length (tree, cfun->gimple_df->ssa_names))
+#define ssa_name(i) (VEC_index (tree, cfun->gimple_df->ssa_names, (i)))
/* Macros for showing usage statistics. */
#define SCALE(x) ((unsigned long) ((x) < 1024*10 \
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);
+extern tree gimple_default_def (struct function *, tree);
/* In tree-phinodes.c */
extern void reserve_phi_args_for_new_edge (basic_block);
};
/* In tree-vectorizer.c */
-unsigned vectorize_loops (struct loops *);
+unsigned vectorize_loops (void);
extern bool vect_can_force_dr_alignment_p (tree, unsigned int);
extern tree get_vectype_for_scalar_type (tree);
/* In tree-ssa-loop*.c */
-void tree_ssa_lim (struct loops *);
-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 *);
+void tree_ssa_lim (void);
+unsigned int tree_ssa_unswitch_loops (void);
+unsigned int canonicalize_induction_variables (void);
+unsigned int tree_unroll_loops_completely (bool);
+unsigned int tree_ssa_prefetch_arrays (void);
+unsigned int remove_empty_loops (void);
+void tree_ssa_iv_optimize (void);
bool number_of_iterations_exit (struct loop *, edge,
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 *);
+void estimate_numbers_of_iterations (void);
bool scev_probably_wraps_p (tree, tree, tree, struct loop *, bool);
bool convert_affine_scev (struct loop *, tree, tree *, tree *, tree, bool);
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 (void);
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);
bool for_each_index (tree *, bool (*) (tree, tree *, void *), 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 *);
basic_block ip_end_pos (struct loop *);
basic_block ip_normal_pos (struct loop *);
-bool tree_duplicate_loop_to_header_edge (struct loop *, edge, struct loops *,
+bool tree_duplicate_loop_to_header_edge (struct loop *, edge,
unsigned int, sbitmap,
edge, edge *,
unsigned int *, int);
-struct loop *tree_ssa_loop_version (struct loops *, struct loop *, tree,
+struct loop *tree_ssa_loop_version (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,
+void tree_unroll_loop (struct loop *, unsigned,
edge, struct tree_niter_desc *);
bool contains_abnormal_ssa_name_p (tree);
bool sra_type_can_be_decomposed_p (tree);
/* In tree-loop-linear.c */
-extern void linear_transform_loops (struct loops *);
+extern void linear_transform_loops (void);
/* In tree-ssa-loop-ivopts.c */
bool expr_invariant_in_loop_p (struct loop *, tree);
void swap_tree_operands (tree, tree *, tree *);
-extern void recalculate_used_alone (void);
-extern bool updating_used_alone;
-
int least_common_multiple (int, int);
#endif /* _TREE_FLOW_H */