#include "hashtab.h"
#include "tree-gimple.h"
#include "tree-ssa-operands.h"
+#include "cgraph.h"
/* Forward declare structures for the garbage collector GTY markers. */
#ifndef GCC_BASIC_BLOCK_H
#endif
/*---------------------------------------------------------------------------
+ Attributes for SSA_NAMEs.
+
+ NOTE: These structures are stored in struct tree_ssa_name
+ but are only used by the tree optimizers, so it makes better sense
+ to declare them here to avoid recompiling unrelated files when
+ making changes.
+---------------------------------------------------------------------------*/
+
+/* Aliasing information for SSA_NAMEs representing pointer variables. */
+struct ptr_info_def GTY(())
+{
+ /* Nonzero if points-to analysis couldn't determine where this pointer
+ 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 is dereferenced. */
+ unsigned int is_dereferenced : 1;
+
+ /* Nonzero if this pointer points to a global variable. */
+ unsigned int pt_global_mem : 1;
+
+ /* Set of variables that this pointer may point to. */
+ bitmap pt_vars;
+
+ /* If this pointer has been dereferenced, and points-to information is
+ more precise than type-based aliasing, indirect references to this
+ pointer will be represented by this memory tag, instead of the type
+ tag computed by TBAA. */
+ tree name_mem_tag;
+};
+
+
+/*---------------------------------------------------------------------------
Tree annotations stored in tree_common.ann
---------------------------------------------------------------------------*/
-enum tree_ann_type { TREE_ANN_COMMON, VAR_ANN, STMT_ANN, SSA_NAME_ANN };
+enum tree_ann_type { TREE_ANN_COMMON, VAR_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;
};
/* It is advantageous to avoid things like life analysis for variables which
{
struct tree_ann_common_d common;
- /* Nonzero if this variable has uses which may not appear
- in the IL. This can happen in the following cases:
-
- 1. If the variable is used in a variable length
- array declaration.
-
- 2. If the variable is the return value in a C++
- function where the named return value optimization
- has been performed. */
- unsigned has_hidden_use : 1;
-
/* Used by the out of SSA pass to determine whether this variable has
been seen yet or not. */
unsigned out_of_ssa_tag : 1;
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
need to be scanned again). */
unsigned modified : 1;
- /* Nonzero if the statement is in the CCP worklist and has not been
- "cancelled". If we ever need to use this bit outside CCP, then
- it should be renamed. */
- unsigned in_ccp_worklist: 1;
-
/* Nonzero if the statement makes aliased loads. */
unsigned makes_aliased_loads : 1;
/* Basic block that contains this statement. */
basic_block GTY ((skip (""))) bb;
- /* Statement operands. */
- struct def_optype_d * GTY (()) def_ops;
- struct use_optype_d * GTY (()) use_ops;
-
- /* Virtual operands (VDEF and VUSE). */
- struct vdef_optype_d * GTY (()) vdef_ops;
- struct vuse_optype_d * GTY (()) vuse_ops;
+ struct stmt_operands_d operands;
/* Dataflow information. */
dataflow_t df;
unsigned int uid;
};
-
-struct ssa_name_ann_d GTY(())
-{
- struct tree_ann_common_d common;
-
- /* Nonzero if points-to analysis couldn't determine where this pointer
- 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;
-
- /* Set of variables that this pointer may point to. */
- bitmap pt_vars;
-
- /* If this pointer has been dereferenced, and points-to information is
- more precise than type-based aliasing, indirect references to this
- pointer will be represented by this memory tag, instead of the type
- tag computed by TBAA. */
- tree name_mem_tag;
-};
-
-
-union tree_ann_d GTY((desc ("ann_type ((tree_ann)&%h)")))
+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 stmt_ann_d GTY((tag ("STMT_ANN"))) stmt;
- struct ssa_name_ann_d GTY((tag ("SSA_NAME_ANN"))) ssa_name;
};
-typedef union tree_ann_d *tree_ann;
+typedef union tree_ann_d *tree_ann_t;
typedef struct var_ann_d *var_ann_t;
typedef struct stmt_ann_d *stmt_ann_t;
-typedef struct ssa_name_ann_d *ssa_name_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 stmt_ann_t stmt_ann (tree);
static inline stmt_ann_t get_stmt_ann (tree);
-static inline ssa_name_ann_t ssa_name_ann (tree);
-static inline ssa_name_ann_t get_ssa_name_ann (tree);
-static inline enum tree_ann_type ann_type (tree_ann);
+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 const char *get_filename (tree);
static inline bool is_exec_stmt (tree);
static inline bool is_label_stmt (tree);
-static inline vdef_optype get_vdef_ops (stmt_ann_t);
+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 int num_immediate_uses (dataflow_t);
static inline tree immediate_use (dataflow_t, int);
static inline dataflow_t get_immediate_uses (tree);
-static inline bool has_hidden_use (tree);
-static inline void set_has_hidden_use (tree);
static inline void set_default_def (tree, tree);
static inline tree default_def (tree);
-static inline bool may_be_aliased (tree);
/*---------------------------------------------------------------------------
Structure representing predictions in tree level.
/* Chain of PHI nodes for this block. */
tree phi_nodes;
- /* Chain of EPHI nodes created in this block. */
- tree ephi_nodes;
-
- /* 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;
-
- /* Nonzero if this block is forwardable during cfg cleanups. This is also
- used to detect loops during cfg cleanups. */
- unsigned forwardable: 1;
-
/* 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;
+
struct edge_prediction *predictions;
};
#define num_referenced_vars VARRAY_ACTIVE_SIZE (referenced_vars)
#define referenced_var(i) VARRAY_TREE (referenced_vars, i)
+/* Array of all SSA_NAMEs used in the function. */
+extern GTY(()) varray_type ssa_names;
+
+#define num_ssa_names VARRAY_ACTIVE_SIZE (ssa_names)
+#define ssa_name(i) VARRAY_TREE (ssa_names, i)
+
/* Artificial variable used to model the effects of function calls. */
extern GTY(()) tree global_var;
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;
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 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 *);
/* Location to track pending stmt for edge insertion. */
#define PENDING_STMT(e) ((e)->insns.t)
-extern void delete_tree_cfg (void);
+extern void delete_tree_cfg_annotations (void);
extern void disband_implicit_edges (void);
extern bool stmt_ends_bb_p (tree);
extern bool is_ctrl_stmt (tree);
extern void debug_cfg_stats (void);
extern void debug_loop_ir (void);
extern void print_loop_ir (FILE *);
-extern void cleanup_tree_cfg (void);
+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 void bsi_insert_on_edge (edge, tree);
-extern void bsi_commit_edge_inserts (int *);
+extern basic_block bsi_insert_on_edge_immediate (edge, tree);
+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 compute_dominance_frontiers (bitmap *);
extern void verify_stmts (void);
+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);
+extern tree gimplify_build1 (block_stmt_iterator *, enum tree_code,
+ tree, tree);
+extern tree gimplify_build2 (block_stmt_iterator *, enum tree_code,
+ tree, tree, tree);
+extern tree gimplify_build3 (block_stmt_iterator *, enum tree_code,
+ tree, tree, tree, tree);
/* 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 stmt_ann_t create_stmt_ann (tree);
-extern ssa_name_ann_t create_ssa_name_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 add_phi_arg (tree, tree, edge);
+extern void remove_phi_args (edge);
extern void remove_phi_node (tree, tree, basic_block);
extern void remove_all_phi_nodes_for (bitmap);
+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 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 tree get_virtual_var (tree);
-extern void add_referenced_tmp_var (tree var);
+extern void add_referenced_tmp_var (tree);
extern void mark_new_vars_to_rename (tree, bitmap);
+extern void find_new_referenced_vars (tree *);
+void mark_call_clobbered_vars_to_rename (void);
+
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
+#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 expand_used_vars (void);
extern void record_vars (tree);
extern bool block_may_fallthru (tree block);
extern void debug_alias_info (void);
extern void dump_points_to_info (FILE *);
extern void debug_points_to_info (void);
+extern void dump_points_to_info_for (FILE *, tree);
+extern void debug_points_to_info_for (tree);
+extern bool may_be_aliased (tree);
+extern struct ptr_info_def *get_ptr_info (tree);
/* 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 *);
+typedef tree tree_on_heap;
+DEF_VEC_MALLOC_P (tree_on_heap);
+
/* In tree-ssa.c */
extern void init_tree_ssa (void);
-extern void rewrite_vars_out_of_ssa (bitmap);
-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 set_is_used (tree);
+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 delete_tree_ssa (void);
-extern void register_new_def (tree, varray_type *);
-extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *);
+extern void register_new_def (tree, VEC (tree_on_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 (void);
+extern void rewrite_into_ssa (bool);
+extern void rewrite_ssa_into_ssa (void);
+extern void rewrite_def_def_chains (void);
-extern unsigned int highest_ssa_version;
-
-/* In tree-ssa-pre.c */
-extern void tree_perform_ssapre (tree, enum tree_dump_index);
+void compute_global_livein (bitmap, bitmap);
+tree duplicate_ssa_name (tree, tree);
/* In tree-ssa-ccp.c */
bool fold_stmt (tree *);
extern void debug_dominator_optimization_stats (void);
/* In tree-ssa-copy.c */
-extern void propagate_value (tree *, tree);
-extern void replace_exp (tree *, tree);
-extern bool cprop_into_stmt (tree, varray_type);
-extern void cprop_into_successor_phis (basic_block, varray_type);
+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);
+
+/* 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). */
+
+struct tree_niter_desc
+{
+ tree assumptions; /* The boolean expression. If this expression evaluates
+ to false, then the other fields in this structure
+ should not be used; there is no guarantee that they
+ will be correct. */
+ tree may_be_zero; /* The boolean expression. If it evaluates to true,
+ the loop will exit in the first iteration (i.e.
+ its latch will not be executed), even if the niter
+ field says otherwise. */
+ tree niter; /* The expression giving the number of iterations of
+ a loop (provided that assumptions == true and
+ may_be_zero == false), more precisely the number
+ of executions of the latch of the loop. */
+ tree additional_info; /* The boolean expression. Sometimes we use additional
+ knowledge to simplify the other expressions
+ contained in this structure (for example the
+ knowledge about value ranges of operands on entry to
+ the loop). If this is a case, conjunction of such
+ condition is stored in this field, so that we do not
+ lose the information: for example if may_be_zero
+ is (n <= 0) and niter is (unsigned) n, we know
+ that the number of iterations is at most
+ 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. */
+};
+
+/* In tree-vectorizer.c */
+void vectorize_loops (struct loops *);
+
+/* 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 *);
+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);
+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);
+void free_numbers_of_iterations_estimates (struct loops *);
+void rewrite_into_loop_closed_ssa (void);
+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);
+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 *,
+ unsigned int, sbitmap,
+ edge, edge *,
+ unsigned int *, int);
+struct loop *tree_ssa_loop_version (struct loops *, struct loop *, tree,
+ basic_block *);
+
+/* In tree-ssa-loop-im.c */
+/* The possibilities of statement movement. */
+
+enum move_pos
+ {
+ MOVE_IMPOSSIBLE, /* No movement -- side effect expression. */
+ MOVE_PRESERVE_EXECUTION, /* Must not cause the non-executed statement
+ become executed -- memory accesses, ... */
+ MOVE_POSSIBLE /* Unlimited movement. */
+ };
+extern enum move_pos movement_possibility (tree);
/* In tree-flow-inline.h */
static inline int phi_arg_from_edge (tree, edge);
-static inline struct phi_arg_d *phi_element_for_edge (tree, edge);
-static inline bool may_propagate_copy (tree, tree);
static inline bool is_call_clobbered (tree);
static inline void mark_call_clobbered (tree);
+static inline void set_is_used (tree);
/* In tree-eh.c */
extern void make_eh_edges (tree);
extern bool tree_could_throw_p (tree);
extern bool tree_can_throw_internal (tree);
extern bool tree_can_throw_external (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);
+
+/* In tree-ssa-pre.c */
+void add_to_value (tree, tree);
+void debug_value_expressions (tree);
+void print_value_expressions (FILE *, 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);
+void vn_init (void);
+void vn_delete (void);
+
+
+/* In tree-sra.c */
+void insert_edge_copies (tree, basic_block);
+
+/* 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);
+/* In gimplify.c */
+
+tree force_gimple_operand (tree, tree *, bool, tree);
#include "tree-flow-inline.h"
OSDN Git Service
