X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-flow.h;h=007550b62e4d4741bae74a204e407bfd299dd617;hb=36d35193ad68600ab7ac6cfe2abab57ce139fe43;hp=6ddf72c2cfc12057a373cc4589a164e415da4a84;hpb=0ec80471fe5e25ecd3dcb82e2147a7c24c9816f5;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index 6ddf72c2cfc..007550b62e4 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -28,6 +28,7 @@ Boston, MA 02111-1307, USA. */ #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 @@ -38,6 +39,45 @@ typedef struct basic_block_def *basic_block; #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 }; @@ -47,6 +87,10 @@ 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; }; @@ -98,17 +142,6 @@ struct var_ann_d GTY(()) { 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; @@ -168,10 +201,10 @@ struct var_ann_d GTY(()) dominator optimizer. */ tree current_def; - /* The set of expressions represented by this variable if it is a - value handle. This is used by GVN-PRE. */ - PTR GTY ((skip)) expr_set; - + /* 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; }; @@ -221,11 +254,6 @@ struct stmt_ann_d GTY(()) 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; @@ -242,14 +270,7 @@ struct stmt_ann_d GTY(()) /* 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 (V_MAY_DEF, VUSE, and V_MUST_DEF). */ - struct v_may_def_optype_d * GTY (()) v_may_def_ops; - struct vuse_optype_d * GTY (()) vuse_ops; - struct v_must_def_optype_d * GTY (()) v_must_def_ops; + struct stmt_operands_d operands; /* Dataflow information. */ dataflow_t df; @@ -299,11 +320,8 @@ 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 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. @@ -324,13 +342,6 @@ struct bb_ann_d GTY(()) /* 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; @@ -338,6 +349,10 @@ struct bb_ann_d GTY(()) /* 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; }; @@ -370,6 +385,10 @@ 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; @@ -397,6 +416,7 @@ typedef struct { 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); 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 *); @@ -450,7 +470,9 @@ extern void dump_cfg_stats (FILE *); 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); @@ -462,13 +484,29 @@ 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 basic_block bsi_insert_on_edge_immediate (edge, tree); extern void bsi_commit_edge_inserts (int *); 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 bb); 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); @@ -495,9 +533,12 @@ 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 tree get_virtual_var (tree); extern void add_referenced_tmp_var (tree var); extern void mark_new_vars_to_rename (tree, bitmap); +extern void find_new_referenced_vars (tree *); + extern void redirect_immediate_uses (tree, tree); extern tree make_rename_temp (tree, const char *); @@ -508,7 +549,6 @@ extern tree make_rename_temp (tree, const char *); /* 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); @@ -519,6 +559,9 @@ extern void dump_alias_info (FILE *); 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); /* Call-back function for walk_use_def_chains(). At each reaching definition, a function with this prototype is called. */ @@ -526,7 +569,6 @@ typedef bool (*walk_use_def_chains_fn) (tree, tree, void *); /* 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 *); @@ -536,16 +578,20 @@ 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 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 walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); +extern void kill_redundant_phi_nodes (void); /* In tree-into-ssa.c */ -extern void rewrite_into_ssa (void); +extern void rewrite_into_ssa (bool); +extern void rewrite_ssa_into_ssa (void); + +void compute_global_livein (bitmap, bitmap); +tree duplicate_ssa_name (tree, tree); /* In tree-ssa-ccp.c */ bool fold_stmt (tree *); @@ -559,14 +605,104 @@ extern void debug_dominator_optimization_stats (void); 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 cprop_into_stmt (tree, varray_type); -extern void cprop_into_successor_phis (basic_block, varray_type, bitmap); +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-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 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); @@ -574,17 +710,44 @@ extern bool tree_could_trap_p (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 */ -tree get_value_handle (tree); -void set_value_handle (tree, 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 stmt, basic_block bb); +/* In tree-ssa-operands.c */ +extern void build_ssa_operands (tree, stmt_ann_t, stmt_operands_p, + stmt_operands_p); + +/* 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 *loop, tree expr); +/* In gimplify.c */ + +tree force_gimple_operand (tree, tree *, bool, tree); + #include "tree-flow-inline.h" #endif /* _TREE_FLOW_H */