/* Data and Control Flow Analysis for Trees.
- Copyright (C) 2001, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
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
typedef struct basic_block_def *basic_block;
#endif
+/* 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;
/* Nonzero if this pointer points to a global variable. */
unsigned int pt_global_mem : 1;
+ /* Nonzero if this pointer points to NULL. */
+ unsigned int pt_null : 1;
+
/* Set of variables that this pointer may point to. */
bitmap pt_vars;
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;
+ 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;
TYPE_TAG,
/* This variable is a name memory tag (NMT). */
- NAME_TAG
+ 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. */
+ tree var;
+
+ /* Offset inside structure. */
+ unsigned HOST_WIDE_INT offset;
+
+ /* Size of the field. */
+ unsigned HOST_WIDE_INT size;
+
+ /* Next subvar for this structure. */
+ subvar_t next;
};
struct var_ann_d GTY(())
states. */
ENUM_BITFIELD (need_phi_state) need_phi_state : 2;
+ /* Used during operand processing to determine if this variable is already
+ in the vuse list. */
+ unsigned in_vuse_list : 1;
+
+ /* Used during operand processing to determine if this variable is already
+ in the v_may_def list. */
+ 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
/* Variables that may alias this variable. */
varray_type may_aliases;
- /* Unique ID of this variable. */
- size_t uid;
-
/* Used when going out of SSA form to indicate which partition this
variable represents storage for. */
unsigned partition;
tree default_def;
/* During into-ssa and the dominator optimizer, this field holds the
- current version of this variable (an SSA_NAME).
-
- This was previously two varrays (one in into-ssa the other in the
- dominator optimizer). That is wasteful, particularly since the
- dominator optimizer calls into-ssa resulting in having two varrays
- live at the same time and this can happen for each call to the
- dominator optimizer. */
+ current version of this variable (an SSA_NAME). */
tree current_def;
-
+
/* Pointer to the structure that contains the sets of global
variables modified by function calls. This field is only used
for FUNCTION_DECLs. */
- static_vars_info_t static_vars_info;
+ ipa_reference_vars_info_t GTY ((skip)) reference_vars_info;
+
+ /* 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 dataflow_d GTY(())
+typedef struct immediate_use_iterator_d
{
- /* Immediate uses. This is a list of all the statements and PHI nodes
- that are immediately reached by the definitions made in this
- statement. */
- varray_type immediate_uses;
-
- /* Use this array for very small numbers of uses instead of the varray. */
- tree uses[2];
-
- /* Reached uses. This is a list of all the possible program statements
- that may be reached directly or indirectly by definitions made in this
- statement. Notice that this is a superset of IMMEDIATE_USES.
- For instance, given the following piece of code:
-
- 1 a1 = 10;
- 2 if (a1 > 3)
- 3 a2 = a1 + 5;
- 4 a3 = PHI (a1, a2)
- 5 b1 = a3 - 2;
-
- IMMEDIATE_USES for statement #1 are all those statements that use a1
- directly (i.e., #2, #3 and #4). REACHED_USES for statement #1 also
- includes statement #5 because 'a1' could reach 'a3' via the PHI node
- at statement #4. The set of REACHED_USES is then the transitive
- closure over all the PHI nodes in the IMMEDIATE_USES set. */
-
- /* Reaching definitions. Similarly to REACHED_USES, the set
- REACHING_DEFS is the set of all the statements that make definitions
- that may reach this statement. Notice that we don't need to have a
- similar entry for immediate definitions, as these are represented by
- the SSA_NAME nodes themselves (each SSA_NAME node contains a pointer
- to the statement that makes that definition). */
-};
+ ssa_use_operand_t *imm_use;
+ ssa_use_operand_t *end_p;
+ ssa_use_operand_t iter_node;
+} imm_use_iterator;
+
+
+/* Use this iterator when simply looking at stmts. Adding, deleting or
+ modifying stmts will cause this iterator to malfunction. */
+
+#define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \
+ for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR)); \
+ !end_readonly_imm_use_p (&(ITER)); \
+ (DEST) = next_readonly_imm_use (&(ITER)))
+
-typedef struct dataflow_d *dataflow_t;
+#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 BREAK_FROM_SAFE_IMM_USE(ITER) \
+ { \
+ end_safe_imm_use_traverse (&(ITER)); \
+ break; \
+ }
struct stmt_ann_d GTY(())
{
unsigned makes_clobbering_call : 1;
/* Basic block that contains this statement. */
- basic_block GTY ((skip (""))) bb;
-
- struct stmt_operands_d operands;
+ basic_block bb;
- /* Dataflow information. */
- dataflow_t df;
+ /* Operand cache for stmt. */
+ struct stmt_operands_d GTY ((skip (""))) operands;
/* Set of variables that have had their address taken in the statement. */
bitmap addresses_taken;
by each pass on an as-needed basis in any order convenient for the
pass which needs statement UIDs. */
unsigned int uid;
+
+ /* 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. */
+
+ void * GTY ((skip (""))) histograms;
};
union tree_ann_d GTY((desc ("ann_type ((tree_ann_t)&%h)")))
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 stmt_ann_d *stmt_ann_t;
static inline enum tree_ann_type ann_type (tree_ann_t);
static inline basic_block bb_for_stmt (tree);
extern void set_bb_for_stmt (tree, basic_block);
-static inline void modify_stmt (tree);
-static inline void unmodify_stmt (tree);
+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 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 v_may_def_optype get_v_may_def_ops (stmt_ann_t);
-static inline vuse_optype get_vuse_ops (stmt_ann_t);
-static inline use_optype get_use_ops (stmt_ann_t);
-static inline def_optype get_def_ops (stmt_ann_t);
static inline bitmap addresses_taken (tree);
-static inline int num_immediate_uses (dataflow_t);
-static inline tree immediate_use (dataflow_t, int);
-static inline dataflow_t get_immediate_uses (tree);
static inline void set_default_def (tree, tree);
static inline tree default_def (tree);
int 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;
+};
- /* Number of predecessors for this block. This is only valid during
- SSA rewriting. It is not maintained after conversion into SSA form. */
- int num_preds;
+extern unsigned int int_tree_map_hash (const void *);
+extern int int_tree_map_eq (const void *, const void *);
- /* Nonzero if this block is forwardable during cfg cleanups. This is also
- used to detect loops during cfg cleanups. */
- unsigned forwardable: 1;
+typedef struct
+{
+ htab_iterator hti;
+} referenced_var_iterator;
- /* Nonzero if this block contains an escape point (see is_escape_site). */
- unsigned has_escape_site : 1;
- /* 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;
+/* 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. */
- struct edge_prediction *predictions;
-};
+#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 bb_ann_d *bb_ann_t;
-/* 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);
+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(()) varray_type referenced_vars;
+extern GTY((param_is (struct int_tree_map))) htab_t referenced_vars;
-#define num_referenced_vars VARRAY_ACTIVE_SIZE (referenced_vars)
-#define referenced_var(i) VARRAY_TREE (referenced_vars, i)
+extern tree referenced_var_lookup (unsigned int);
+extern tree referenced_var_lookup_if_exists (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(()) varray_type ssa_names;
+extern GTY(()) VEC(tree,gc) *ssa_names;
-#define num_ssa_names VARRAY_ACTIVE_SIZE (ssa_names)
-#define ssa_name(i) VARRAY_TREE (ssa_names, i)
+#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;
#define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y))
-
/*---------------------------------------------------------------------------
Block iterators
---------------------------------------------------------------------------*/
static inline block_stmt_iterator bsi_start (basic_block);
static inline block_stmt_iterator bsi_last (basic_block);
static inline block_stmt_iterator bsi_after_labels (basic_block);
-block_stmt_iterator stmt_for_bsi (tree);
+block_stmt_iterator bsi_for_stmt (tree);
static inline bool bsi_end_p (block_stmt_iterator);
static inline void bsi_next (block_stmt_iterator *);
static inline void bsi_prev (block_stmt_iterator *);
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 tree first_stmt (basic_block);
extern tree last_stmt (basic_block);
extern tree *last_stmt_ptr (basic_block);
extern tree last_and_only_stmt (basic_block);
extern edge find_taken_edge (basic_block, tree);
-extern void cfg_remove_useless_stmts (void);
-extern edge thread_edge (edge, basic_block);
-extern basic_block label_to_block (tree);
-extern void tree_optimize_tail_calls (bool, enum tree_dump_index);
-extern edge tree_block_forwards_to (basic_block bb);
+extern basic_block label_to_block_fn (struct function *, tree);
+#define label_to_block(t) (label_to_block_fn (cfun, t))
extern void bsi_insert_on_edge (edge, tree);
extern basic_block bsi_insert_on_edge_immediate (edge, tree);
-extern void bsi_commit_edge_inserts (int *);
+extern void bsi_commit_one_edge_insert (edge, basic_block *);
+extern void bsi_commit_edge_inserts (void);
extern void notice_special_calls (tree);
extern void clear_special_calls (void);
extern void verify_stmts (void);
-extern tree tree_block_label (basic_block bb);
+extern tree tree_block_label (basic_block);
extern void extract_true_false_edges_from_block (basic_block, edge *, edge *);
extern bool tree_duplicate_sese_region (edge, edge, basic_block *, unsigned,
basic_block *);
extern void add_phi_args_after_copy_bb (basic_block);
extern void add_phi_args_after_copy (basic_block *, unsigned);
-extern void rewrite_to_new_ssa_names_bb (basic_block, struct htab *);
-extern void rewrite_to_new_ssa_names (basic_block *, unsigned, htab_t);
-extern void allocate_ssa_names (bitmap, struct htab **);
extern bool tree_purge_dead_eh_edges (basic_block);
extern bool tree_purge_all_dead_eh_edges (bitmap);
extern tree gimplify_val (block_stmt_iterator *, tree, tree);
tree, tree, tree);
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 mark_array_ref_addressable (void);
+extern void replace_uses_by (tree, tree);
+extern void start_recording_case_labels (void);
+extern void end_recording_case_labels (void);
+
+/* 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);
extern var_ann_t create_var_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_arg (tree, basic_block);
-extern void remove_phi_arg_num (tree, int);
-extern void remove_phi_node (tree, tree, basic_block);
-extern void remove_all_phi_nodes_for (bitmap);
+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_immediate_uses (FILE *);
-extern void debug_immediate_uses (void);
-extern void dump_immediate_uses_for (FILE *, tree);
-extern void debug_immediate_uses_for (tree);
-extern void compute_immediate_uses (int, bool (*)(tree));
-extern void free_df (void);
-extern void free_df_for_stmt (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 var);
-extern void mark_new_vars_to_rename (tree, bitmap);
+extern void add_referenced_tmp_var (tree);
+extern void mark_new_vars_to_rename (tree);
extern void find_new_referenced_vars (tree *);
-extern void redirect_immediate_uses (tree, tree);
extern tree make_rename_temp (tree, const char *);
-/* Flags used when computing reaching definitions and reached uses. */
-#define TDFA_USE_OPS 1 << 0
-#define TDFA_USE_VOPS 1 << 1
-
/* In gimple-low.c */
-struct lower_data;
-extern void lower_stmt_body (tree, struct lower_data *);
extern void record_vars (tree);
extern bool block_may_fallthru (tree block);
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);
+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);
+static inline bool ref_contains_indirect_ref (tree);
+extern tree okay_component_ref_for_subvars (tree, unsigned HOST_WIDE_INT *,
+ unsigned HOST_WIDE_INT *);
+static inline bool var_can_have_subvars (tree);
+static inline bool overlap_subvar (unsigned HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT,
+ subvar_t, bool *);
/* Call-back function for walk_use_def_chains(). At each reaching
definition, a function with this prototype is called. */
typedef bool (*walk_use_def_chains_fn) (tree, tree, void *);
+
/* In tree-ssa.c */
extern void init_tree_ssa (void);
-extern void dump_reaching_defs (FILE *);
-extern void debug_reaching_defs (void);
-extern void dump_tree_ssa (FILE *);
-extern void debug_tree_ssa (void);
-extern void debug_def_blocks (void);
-extern void dump_tree_ssa_stats (FILE *);
-extern void debug_tree_ssa_stats (void);
-extern void ssa_remove_edge (edge);
extern edge ssa_redirect_edge (edge, basic_block);
+extern void flush_pending_stmts (edge);
extern bool tree_ssa_useless_type_conversion (tree);
extern bool tree_ssa_useless_type_conversion_1 (tree, tree);
-extern void verify_ssa (void);
+extern void verify_ssa (bool);
extern void delete_tree_ssa (void);
-extern void register_new_def (tree, varray_type *);
+extern void register_new_def (tree, VEC(tree,heap) **);
extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool);
-extern void kill_redundant_phi_nodes (void);
+extern bool stmt_references_memory_p (tree);
/* In tree-into-ssa.c */
-extern void rewrite_into_ssa (bool);
-extern void rewrite_ssa_into_ssa (void);
-
+void update_ssa (unsigned);
+void delete_update_ssa (void);
+void register_new_name_mapping (tree, tree);
+tree create_new_def_for (tree, tree, def_operand_p);
+bool need_ssa_update_p (void);
+bool name_registered_for_update_p (tree);
+bitmap ssa_names_to_replace (void);
+void release_ssa_name_after_update_ssa (tree name);
void compute_global_livein (bitmap, bitmap);
tree duplicate_ssa_name (tree, tree);
+void mark_sym_for_renaming (tree);
+void mark_set_for_renaming (bitmap);
+tree get_current_def (tree);
+void set_current_def (tree, tree);
/* In tree-ssa-ccp.c */
bool fold_stmt (tree *);
+bool fold_stmt_inplace (tree);
tree widen_bitfield (tree, tree, tree);
+/* In tree-vrp.c */
+tree vrp_evaluate_conditional (tree, bool);
+void simplify_stmt_using_ranges (tree);
+
/* In tree-ssa-dom.c */
extern void dump_dominator_optimization_stats (FILE *);
extern void debug_dominator_optimization_stats (void);
+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);
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 *);
+void tree_unroll_loops_completely (struct loops *, bool);
+void remove_empty_loops (struct loops *);
void tree_ssa_iv_optimize (struct loops *);
-void number_of_iterations_cond (tree, tree, tree, enum tree_code, tree, tree,
- struct tree_niter_desc *);
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, tree, struct loop *, bool *,
+ bool *);
+tree convert_step (struct loop *, tree, tree, tree, tree);
void free_numbers_of_iterations_estimates (struct loops *);
-void rewrite_into_loop_closed_ssa (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);
+void compute_phi_arg_on_exit (edge, tree, tree);
+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 *);
/* In tree-ssa-loop-im.c */
/* The possibilities of statement movement. */
};
extern enum move_pos movement_possibility (tree);
-/* In tree-if-conv.c */
-bool tree_if_conversion (struct loop *, bool);
-
-
/* In tree-flow-inline.h */
-static inline int phi_arg_from_edge (tree, edge);
static inline bool is_call_clobbered (tree);
static inline void mark_call_clobbered (tree);
static inline void set_is_used (tree);
+static inline bool unmodifiable_var_p (tree);
/* In tree-eh.c */
extern void make_eh_edges (tree);
extern int lookup_stmt_eh_region (tree);
extern void add_stmt_to_eh_region (tree, int);
extern bool remove_stmt_from_eh_region (tree);
-extern bool maybe_clean_eh_stmt (tree);
+extern bool maybe_clean_or_replace_eh_stmt (tree, tree);
/* In tree-ssa-pre.c */
void add_to_value (tree, tree);
/* In tree-vn.c */
bool expressions_equal_p (tree, tree);
tree get_value_handle (tree);
-hashval_t vn_compute (tree, hashval_t, vuse_optype);
-tree vn_lookup_or_add (tree, vuse_optype);
-void vn_add (tree, tree, vuse_optype);
-tree vn_lookup (tree, vuse_optype);
+hashval_t vn_compute (tree, hashval_t, tree);
+tree vn_lookup_or_add (tree, tree);
+void vn_add (tree, tree, tree);
+tree vn_lookup (tree, tree);
void vn_init (void);
void vn_delete (void);
+/* In tree-ssa-sink.c */
+bool is_hidden_global_store (tree);
/* In tree-sra.c */
-void insert_edge_copies (tree stmt, basic_block bb);
-
-/* In tree-ssa-operands.c */
-extern void build_ssa_operands (tree, stmt_ann_t, stmt_operands_p,
- stmt_operands_p);
+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 gimplify.c */
+/* In tree-ssa-loop-ivopts.c */
+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 (bitmap);
+
+/* 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-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 field;
+ 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) *);
#include "tree-flow-inline.h"