X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-flow.h;h=389ec8f94d0d435fa6432c558686f3ba952b00ca;hb=2563794c46cbe142145afaf0597a43b9eafc951a;hp=55ff2e7404b153f2e10d55a955d0cacb88624b73;hpb=77ae8b0f8f27f3337b5c96ae039fa46f08aba19c;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index 55ff2e7404b..389ec8f94d0 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -16,8 +16,8 @@ GNU General Public License for more details. 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 @@ -29,6 +29,7 @@ Boston, MA 02111-1307, USA. */ #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 @@ -38,6 +39,23 @@ struct basic_block_def; 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. @@ -54,9 +72,6 @@ struct ptr_info_def GTY(()) 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; @@ -66,6 +81,9 @@ struct ptr_info_def GTY(()) /* 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; @@ -88,8 +106,8 @@ struct tree_ann_common_d GTY(()) 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; @@ -135,7 +153,29 @@ enum mem_tag_kind { 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(()) @@ -183,9 +223,6 @@ struct var_ann_d GTY(()) /* 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; @@ -200,54 +237,47 @@ struct var_ann_d GTY(()) 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. */ + 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. */ -typedef struct dataflow_d *dataflow_t; +#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))) + + +#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(()) { @@ -271,12 +301,10 @@ 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; @@ -285,6 +313,12 @@ struct stmt_ann_d GTY(()) 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)"))) @@ -294,6 +328,8 @@ 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; @@ -307,22 +343,15 @@ static inline stmt_ann_t get_stmt_ann (tree); 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); @@ -337,45 +366,71 @@ struct edge_prediction GTY((chain_next ("%h.next"))) 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; +}; - /* 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(()) 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; @@ -402,7 +457,6 @@ extern bool aliases_computed_p; #define PERCENT(x,y) ((float)(x) * 100.0 / (float)(y)) - /*--------------------------------------------------------------------------- Block iterators ---------------------------------------------------------------------------*/ @@ -471,14 +525,13 @@ extern void debug_loop_ir (void); 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 basic_block label_to_block (tree); +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_one_edge_insert (edge, basic_block *); @@ -492,9 +545,6 @@ 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); @@ -504,6 +554,15 @@ 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); +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); + +/* 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); @@ -516,8 +575,7 @@ 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, basic_block); -extern void remove_all_phi_nodes_for (bitmap); +extern void remove_phi_node (tree, tree); extern tree phi_reverse (tree); extern void dump_dfa_stats (FILE *); extern void debug_dfa_stats (void); @@ -525,29 +583,16 @@ 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); -extern void mark_new_vars_to_rename (tree, bitmap); +extern void mark_new_vars_to_rename (tree); 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) - /* 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); @@ -561,50 +606,71 @@ 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 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 array_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 *); -typedef tree tree_on_heap; -DEF_VEC_MALLOC_P (tree_on_heap); /* In tree-ssa.c */ extern void init_tree_ssa (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 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, VEC (tree_on_heap) **); +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); -extern void rewrite_def_def_chains (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); @@ -654,25 +720,30 @@ bool empty_block_p (basic_block); 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 *); @@ -684,6 +755,9 @@ bool tree_duplicate_loop_to_header_edge (struct loop *, edge, struct loops *, 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. */ @@ -701,6 +775,7 @@ extern enum move_pos movement_possibility (tree); 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); @@ -711,7 +786,7 @@ 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); +extern bool maybe_clean_or_replace_eh_stmt (tree, tree); /* In tree-ssa-pre.c */ void add_to_value (tree, tree); @@ -722,25 +797,99 @@ 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); +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, 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); -/* In gimplify.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"