X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-flow.h;h=636a6f0ba55adfc490a36384a418ea7aee77de77;hb=fbbc6fdbe73dde1b85b992579ce30f6d90ea62e8;hp=60d7f2ac09a9a68c1ec24ee148d0470e869baf65;hpb=db22d3cc2fb885dec7aea38a58ee7775d93d7dd1;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index 60d7f2ac09a..636a6f0ba55 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -1,12 +1,13 @@ /* Data and Control Flow Analysis for Trees. - Copyright (C) 2001, 2003, 2004, 2005 Free Software Foundation, Inc. + Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007 + Free Software Foundation, Inc. Contributed by Diego Novillo This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) +the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, @@ -15,9 +16,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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, 51 Franklin Street, Fifth Floor, -Boston, MA 02110-1301, USA. */ +along with GCC; see the file COPYING3. If not see +. */ #ifndef _TREE_FLOW_H #define _TREE_FLOW_H 1 @@ -38,9 +38,153 @@ typedef struct edge_def *edge; struct basic_block_def; typedef struct basic_block_def *basic_block; #endif +struct static_var_ann_d; + +/* Memory reference statistics for individual memory symbols, + collected during alias analysis. */ +struct mem_sym_stats_d GTY(()) +{ + /* Memory symbol. */ + tree var; + + /* Nonzero if this entry has been assigned a partition. */ + unsigned int partitioned_p : 1; + + /* Nonzero if VAR is a memory partition tag that already contains + call-clobbered variables in its partition set. */ + unsigned int has_call_clobbered_vars : 1; + + /* Number of direct reference sites. A direct reference to VAR is any + reference of the form 'VAR = ' or ' = VAR'. For GIMPLE reg + pointers, this is the number of sites where the pointer is + dereferenced. */ + long num_direct_writes; + long num_direct_reads; + + /* Number of indirect reference sites. An indirect reference to VAR + is any reference via a pointer that contains VAR in its points-to + set or, in the case of call-clobbered symbols, a function call. */ + long num_indirect_writes; + long num_indirect_reads; + + /* Execution frequency. This is the sum of the execution + frequencies of all the statements that reference this object + weighted by the number of references in each statement. This is + the main key used to sort the list of symbols to partition. + Symbols with high execution frequencies are put at the bottom of + the work list (ie, they are partitioned last). + Execution frequencies are taken directly from each basic block, + so compiling with PGO enabled will increase the precision of this + estimate. */ + long frequency_reads; + long frequency_writes; + + /* Set of memory tags that contain VAR in their alias set. */ + bitmap parent_tags; +}; + +typedef struct mem_sym_stats_d *mem_sym_stats_t; +DEF_VEC_P(mem_sym_stats_t); +DEF_VEC_ALLOC_P(mem_sym_stats_t, heap); + +/* Memory reference statistics collected during alias analysis. */ +struct mem_ref_stats_d GTY(()) +{ + /* Number of statements that make memory references. */ + long num_mem_stmts; + + /* Number of statements that make function calls. */ + long num_call_sites; + + /* Number of statements that make calls to pure/const functions. */ + long num_pure_const_call_sites; + + /* Number of ASM statements. */ + long num_asm_sites; + + /* Estimated number of virtual operands needed as computed by + compute_memory_partitions. */ + long num_vuses; + long num_vdefs; + + /* This maps every symbol used to make "memory" references + (pointers, arrays, structures, etc) to an instance of struct + mem_sym_stats_d describing reference statistics for the symbol. */ + struct pointer_map_t * GTY((skip)) mem_sym_stats; +}; -/* 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; + + /* Hashtable of variables annotations. Used for static variables only; + local variables have direct pointer in the tree node. */ + htab_t GTY((param_is (struct static_var_ann_d))) var_anns; + + /* Memory reference statistics collected during alias analysis. + This information is used to drive the memory partitioning + heuristics in compute_memory_partitions. */ + struct mem_ref_stats_d mem_ref_stats; +}; + +/* 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 { @@ -92,11 +236,14 @@ struct ptr_info_def GTY(()) pointer will be represented by this memory tag, instead of the type tag computed by TBAA. */ tree name_mem_tag; + + /* Mask of reasons this pointer's value escapes the function */ + unsigned int escape_mask; }; /*--------------------------------------------------------------------------- - 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 }; @@ -137,6 +284,30 @@ enum need_phi_state { NEED_PHI_STATE_MAYBE }; + +/* The "no alias" attribute allows alias analysis to make more + aggressive assumptions when assigning alias sets, computing + points-to information and memory partitions. These attributes + are the result of user annotations or flags (e.g., + -fargument-noalias). */ +enum noalias_state { + /* Default state. No special assumptions can be made about this + symbol. */ + MAY_ALIAS = 0, + + /* The symbol does not alias with other symbols that have a + NO_ALIAS* attribute. */ + NO_ALIAS, + + /* The symbol does not alias with other symbols that have a + NO_ALIAS*, and it may not alias with global symbols. */ + NO_ALIAS_GLOBAL, + + /* The symbol does not alias with any other symbols. */ + NO_ALIAS_ANYTHING +}; + + struct subvar; typedef struct subvar *subvar_t; @@ -146,12 +317,6 @@ 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; }; @@ -164,13 +329,8 @@ struct var_ann_d GTY(()) been seen yet or not. */ unsigned out_of_ssa_tag : 1; - /* Used when building root_var structures in tree_ssa_live.[ch]. */ - unsigned root_var_processed : 1; - - /* Nonzero if this variable is an alias tag that represents references to - other variables (i.e., this variable appears in the MAY_ALIASES array - of other variables). */ - unsigned is_alias_tag : 1; + /* Used when building base variable structures in a var_map. */ + unsigned base_var_processed : 1; /* Nonzero if this variable was used after SSA optimizations were applied. We set this when translating out of SSA form. */ @@ -182,37 +342,63 @@ struct var_ann_d GTY(()) ENUM_BITFIELD (need_phi_state) need_phi_state : 2; /* Used during operand processing to determine if this variable is already - in the vuse list. */ + 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; + in the VDEF list. */ + unsigned in_vdef_list : 1; + + /* True for HEAP artificial variables. These variables represent + the memory area allocated by a call to malloc. */ + unsigned is_heapvar : 1; + + /* True if the variable is call clobbered. */ + unsigned int call_clobbered : 1; + + /* This field describes several "no alias" attributes that some + symbols are known to have. See the enum's definition for more + information on each attribute. */ + ENUM_BITFIELD (noalias_state) noalias_state : 2; - /* 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 - dereferenced, this must be NULL. */ - tree type_mem_tag; + /* Memory partition tag assigned to this symbol. */ + tree mpt; - /* Variables that may alias this variable. */ - VEC(tree, gc) *may_aliases; + /* If this variable is a pointer P that has been dereferenced, this + field is an artificial variable that represents the memory + location *P. Every other pointer Q that is type-compatible with + P will also have the same memory tag. If the variable is not a + pointer or if it is never dereferenced, this must be NULL. + FIXME, do we really need this here? How much slower would it be + to convert to hash table? */ + tree symbol_mem_tag; /* Used when going out of SSA form to indicate which partition this variable represents storage for. */ unsigned partition; - /* Used by the root-var object in tree-ssa-live.[ch]. */ - unsigned root_index; + /* Used by var_map for the base index of ssa base variables. */ + unsigned base_index; /* 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; + + /* Mask of values saying the reasons why this variable has escaped + the function. */ + unsigned int escape_mask; +}; + +/* Container for variable annotation used by hashtable for annotations for + static variables. */ +struct static_var_ann_d GTY(()) +{ + struct var_ann_d ann; + unsigned int uid; }; struct function_ann_d GTY(()) @@ -227,9 +413,15 @@ struct function_ann_d GTY(()) typedef struct immediate_use_iterator_d { + /* This is the current use the iterator is processing. */ ssa_use_operand_t *imm_use; + /* This marks the last use in the list (use node from SSA_NAME) */ ssa_use_operand_t *end_p; + /* This node is inserted and used to mark the end of the uses for a stmt. */ ssa_use_operand_t iter_node; + /* This is the next ssa_name to visit. IMM_USE may get removed before + the next one is traversed to, so it must be cached early. */ + ssa_use_operand_t *next_imm_name; } imm_use_iterator; @@ -241,32 +433,46 @@ typedef struct immediate_use_iterator_d !end_readonly_imm_use_p (&(ITER)); \ (DEST) = next_readonly_imm_use (&(ITER))) +/* Use this iterator to visit each stmt which has a use of SSAVAR. */ -#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 FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR) \ + for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR)); \ + !end_imm_use_stmt_p (&(ITER)); \ + (STMT) = next_imm_use_stmt (&(ITER))) -#define BREAK_FROM_SAFE_IMM_USE(ITER) \ +/* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early. Failure to + do so will result in leaving a iterator marker node in the immediate + use list, and nothing good will come from that. */ +#define BREAK_FROM_IMM_USE_STMT(ITER) \ { \ - end_safe_imm_use_traverse (&(ITER)); \ + end_imm_use_stmt_traverse (&(ITER)); \ break; \ } -struct stmt_ann_d GTY(()) -{ - struct tree_ann_common_d common; - /* Nonzero if the statement has been modified (meaning that the operands - need to be scanned again). */ - unsigned modified : 1; +/* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to + get access to each occurrence of ssavar on the stmt returned by + that iterator.. for instance: - /* Nonzero if the statement makes references to volatile storage. */ - unsigned has_volatile_ops : 1; + FOR_EACH_IMM_USE_STMT (stmt, iter, var) + { + FOR_EACH_IMM_USE_ON_STMT (use_p, iter) + { + SET_USE (use_p) = blah; + } + update_stmt (stmt); + } */ - /* Nonzero if the statement makes a function call that may clobber global - and local addressable variables. */ - unsigned makes_clobbering_call : 1; +#define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER) \ + for ((DEST) = first_imm_use_on_stmt (&(ITER)); \ + !end_imm_use_on_stmt_p (&(ITER)); \ + (DEST) = next_imm_use_on_stmt (&(ITER))) + + + +struct stmt_ann_d GTY(()) +{ + struct tree_ann_common_d common; /* Basic block that contains this statement. */ basic_block bb; @@ -282,11 +488,16 @@ struct stmt_ann_d GTY(()) 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; + /* Nonzero if the statement references memory (at least one of its + expressions contains a non-register operand). */ + unsigned references_memory : 1; + + /* Nonzero if the statement has been modified (meaning that the operands + need to be scanned again). */ + unsigned modified : 1; + + /* Nonzero if the statement makes references to volatile storage. */ + unsigned has_volatile_ops : 1; }; union tree_ann_d GTY((desc ("ann_type ((tree_ann_t)&%h)"))) @@ -297,20 +508,20 @@ 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 function_ann_d *function_ann_t; typedef struct stmt_ann_d *stmt_ann_t; +typedef struct tree_ann_common_d *tree_ann_common_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 tree_ann_common_t tree_common_ann (const_tree); +static inline tree_ann_common_t get_tree_common_ann (tree); +static inline var_ann_t var_ann (const_tree); static inline var_ann_t get_var_ann (tree); -static inline function_ann_t function_ann (tree); +static inline function_ann_t function_ann (const_tree); static inline function_ann_t get_function_ann (tree); static inline stmt_ann_t stmt_ann (tree); +static inline bool has_stmt_ann (tree); 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); @@ -318,11 +529,8 @@ extern void set_bb_for_stmt (tree, basic_block); static inline bool noreturn_call_p (tree); static inline void update_stmt (tree); static inline bool stmt_modified_p (tree); -static inline VEC(tree, gc) *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 bitmap may_aliases (const_tree); +static inline int get_lineno (const_tree); static inline bitmap addresses_taken (tree); /*--------------------------------------------------------------------------- @@ -337,7 +545,7 @@ struct edge_prediction GTY((chain_next ("%h.ep_next"))) }; /* Accessors for basic block annotations. */ -static inline tree phi_nodes (basic_block); +static inline tree phi_nodes (const_basic_block); static inline void set_phi_nodes (basic_block, tree); /*--------------------------------------------------------------------------- @@ -388,36 +596,13 @@ typedef struct 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 tree referenced_var_lookup_if_exists (unsigned int); -#define num_referenced_vars htab_elements (referenced_vars) +extern bool referenced_var_check_and_insert (tree); +#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; - -/* 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 \ @@ -449,7 +634,7 @@ static inline void bsi_prev (block_stmt_iterator *); static inline tree bsi_stmt (block_stmt_iterator); static inline tree * bsi_stmt_ptr (block_stmt_iterator); -extern void bsi_remove (block_stmt_iterator *); +extern void bsi_remove (block_stmt_iterator *, bool); extern void bsi_move_before (block_stmt_iterator *, block_stmt_iterator *); extern void bsi_move_after (block_stmt_iterator *, block_stmt_iterator *); extern void bsi_move_to_bb_end (block_stmt_iterator *, basic_block); @@ -473,6 +658,56 @@ extern void bsi_insert_after (block_stmt_iterator *, tree, extern void bsi_replace (const block_stmt_iterator *, tree, bool); /*--------------------------------------------------------------------------- + OpenMP Region Tree +---------------------------------------------------------------------------*/ + +/* Parallel region information. Every parallel and workshare + directive is enclosed between two markers, the OMP_* directive + and a corresponding OMP_RETURN statement. */ + +struct omp_region +{ + /* The enclosing region. */ + struct omp_region *outer; + + /* First child region. */ + struct omp_region *inner; + + /* Next peer region. */ + struct omp_region *next; + + /* Block containing the omp directive as its last stmt. */ + basic_block entry; + + /* Block containing the OMP_RETURN as its last stmt. */ + basic_block exit; + + /* Block containing the OMP_CONTINUE as its last stmt. */ + basic_block cont; + + /* If this is a combined parallel+workshare region, this is a list + of additional arguments needed by the combined parallel+workshare + library call. */ + tree ws_args; + + /* The code for the omp directive of this region. */ + enum tree_code type; + + /* Schedule kind, only used for OMP_FOR type regions. */ + enum omp_clause_schedule_kind sched_kind; + + /* True if this is a combined parallel+workshare region. */ + bool is_combined_parallel; +}; + +extern struct omp_region *root_omp_region; +extern struct omp_region *new_omp_region (basic_block, enum tree_code, + struct omp_region *); +extern void free_omp_regions (void); +extern tree find_omp_clause (tree, enum tree_code); +tree copy_var_decl (tree, tree, tree); + +/*--------------------------------------------------------------------------- Function prototypes ---------------------------------------------------------------------------*/ /* In tree-cfg.c */ @@ -481,12 +716,13 @@ extern void bsi_replace (const block_stmt_iterator *, tree, bool); #define PENDING_STMT(e) ((e)->insns.t) 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 bool is_ctrl_altering_stmt (tree); -extern bool computed_goto_p (tree); -extern bool simple_goto_p (tree); +extern bool stmt_ends_bb_p (const_tree); +extern bool is_ctrl_stmt (const_tree); +extern bool is_ctrl_altering_stmt (const_tree); +extern bool computed_goto_p (const_tree); +extern bool simple_goto_p (const_tree); +extern bool tree_can_make_abnormal_goto (const_tree); +extern basic_block single_noncomplex_succ (basic_block bb); extern void tree_dump_bb (basic_block, FILE *, int); extern void debug_tree_bb (basic_block); extern basic_block debug_tree_bb_n (int); @@ -500,7 +736,6 @@ extern void cleanup_dead_labels (void); extern void group_case_labels (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 basic_block label_to_block_fn (struct function *, tree); @@ -512,14 +747,17 @@ 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 void verify_gimple (void); +extern void verify_gimple_1 (tree); 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 bool tree_purge_dead_abnormal_call_edges (basic_block); extern bool tree_purge_dead_eh_edges (basic_block); -extern bool tree_purge_all_dead_eh_edges (bitmap); +extern bool tree_purge_all_dead_eh_edges (const_bitmap); extern tree gimplify_val (block_stmt_iterator *, tree, tree); extern tree gimplify_build1 (block_stmt_iterator *, enum tree_code, tree, tree); @@ -529,22 +767,27 @@ 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 make_abnormal_goto_edges (basic_block, bool); extern void replace_uses_by (tree, tree); extern void start_recording_case_labels (void); extern void end_recording_case_labels (void); +extern basic_block move_sese_region_to_fn (struct function *, basic_block, + basic_block); +void remove_edge_and_dominated_blocks (edge); /* In tree-cfgcleanup.c */ +extern bitmap cfgcleanup_altered_bbs; 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 const char *op_symbol_code (enum tree_code); /* In tree-dfa.c */ extern var_ann_t create_var_ann (tree); extern function_ann_t create_function_ann (tree); extern stmt_ann_t create_stmt_ann (tree); -extern tree_ann_t create_tree_ann (tree); +extern tree_ann_common_t create_tree_common_ann (tree); extern void dump_dfa_stats (FILE *); extern void debug_dfa_stats (void); extern void debug_referenced_vars (void); @@ -554,28 +797,30 @@ extern void debug_variable (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); +extern void add_referenced_var (tree); +extern void remove_referenced_var (tree); +extern void mark_symbols_for_renaming (tree); extern void find_new_referenced_vars (tree *); - 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); +extern struct mem_sym_stats_d *mem_sym_stats (struct function *, tree); /* In tree-phinodes.c */ 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); +extern void remove_phi_node (tree, tree, bool); extern tree phi_reverse (tree); /* In gimple-low.c */ +extern void record_vars_into (tree, tree); extern void record_vars (tree); -extern bool block_may_fallthru (tree block); +extern bool block_may_fallthru (const_tree); /* In tree-ssa-alias.c */ +extern unsigned int compute_may_aliases (void); extern void dump_may_aliases_for (FILE *, tree); extern void debug_may_aliases_for (tree); extern void dump_alias_info (FILE *); @@ -585,36 +830,44 @@ 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 *); +extern void new_type_alias (tree, tree, tree); +extern void count_uses_and_derefs (tree, tree, unsigned *, unsigned *, + unsigned *); 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); +static inline bool ref_contains_array_ref (const_tree); +static inline bool array_ref_contains_indirect_ref (const_tree); extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, HOST_WIDE_INT *, HOST_WIDE_INT *); -static inline bool var_can_have_subvars (tree); +static inline bool var_can_have_subvars (const_tree); static inline bool overlap_subvar (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, - subvar_t, bool *); + const_tree, bool *); +extern tree create_tag_raw (enum tree_code, tree, const char *); +extern void delete_mem_ref_stats (struct function *); +extern void dump_mem_ref_stats (FILE *); +extern void debug_mem_ref_stats (void); +extern void debug_memory_partitions (void); +extern void debug_mem_sym_stats (tree var); +extern void debug_all_mem_sym_stats (void); /* 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-alias-warnings.c */ +extern void strict_aliasing_warning_backend (void); /* In tree-ssa.c */ extern void init_tree_ssa (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 bool useless_type_conversion_p (tree, tree); +extern bool types_compatible_p (tree, tree); extern void verify_ssa (bool); extern void delete_tree_ssa (void); -extern void register_new_def (tree, VEC(tree,heap) **); extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); extern bool stmt_references_memory_p (tree); @@ -624,9 +877,10 @@ 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_mappings_registered_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 release_ssa_name_after_update_ssa (tree); void compute_global_livein (bitmap, bitmap); tree duplicate_ssa_name (tree, tree); void mark_sym_for_renaming (tree); @@ -640,7 +894,7 @@ bool fold_stmt_inplace (tree); tree widen_bitfield (tree, tree, tree); /* In tree-vrp.c */ -tree vrp_evaluate_conditional (tree, bool); +tree vrp_evaluate_conditional (tree, tree); void simplify_stmt_using_ranges (tree); /* In tree-ssa-dom.c */ @@ -656,6 +910,17 @@ extern void replace_exp (use_operand_p, tree); extern bool may_propagate_copy (tree, tree); extern bool may_propagate_copy_into_asm (tree); +/* Affine iv. */ + +typedef struct +{ + /* Iv = BASE + STEP * i. */ + tree base, step; + + /* True if this iv does not overflow. */ + bool no_overflow; +} affine_iv; + /* 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). */ @@ -674,69 +939,90 @@ struct tree_niter_desc 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. */ + double_int max; /* The upper bound on the number of iterations of + the loop. */ + + /* The simplified shape of the exit condition. The loop exits if + CONTROL CMP BOUND is false, where CMP is one of NE_EXPR, + LT_EXPR, or GT_EXPR, and step of CONTROL is positive if CMP is + LE_EXPR and negative if CMP is GE_EXPR. This information is used + by loop unrolling. */ + affine_iv control; + tree bound; + enum tree_code cmp; }; /* In tree-vectorizer.c */ -void vectorize_loops (struct loops *); +unsigned vectorize_loops (void); +extern bool vect_can_force_dr_alignment_p (const_tree, unsigned int); +extern tree get_vectype_for_scalar_type (tree); /* In tree-ssa-phiopt.c */ bool empty_block_p (basic_block); +basic_block *blocks_in_phiopt_order (void); /* 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 *, bool); -void 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); +unsigned tree_predictive_commoning (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 *); -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 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); + +bool nowrap_type_p (tree); +enum ev_direction {EV_DIR_GROWS, EV_DIR_DECREASES, EV_DIR_UNKNOWN}; +enum ev_direction scev_direction (const_tree); + +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); -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 *); 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, + edge, VEC (edge, heap) **, + int); +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 loop *, unsigned, + edge, struct tree_niter_desc *); +typedef void (*transform_callback)(struct loop *, void *); +void tree_transform_and_unroll_loop (struct loop *, unsigned, + edge, struct tree_niter_desc *, + transform_callback, void *); +bool contains_abnormal_ssa_name_p (tree); +bool stmt_dominates_stmt_p (tree, tree); +void mark_virtual_ops_for_renaming (tree); + +/* In tree-ssa-threadedge.c */ +extern bool potentially_threadable_block (basic_block); +extern void thread_across_edge (tree, edge, bool, + VEC(tree, heap) **, tree (*) (tree, tree)); /* In tree-ssa-loop-im.c */ /* The possibilities of statement movement. */ @@ -749,20 +1035,40 @@ enum move_pos MOVE_POSSIBLE /* Unlimited movement. */ }; extern enum move_pos movement_possibility (tree); +char *get_lsm_tmp_name (tree, unsigned); + +/* The reasons a variable may escape a function. */ +enum escape_type +{ + NO_ESCAPE = 0, /* Doesn't escape. */ + ESCAPE_STORED_IN_GLOBAL = 1 << 1, + ESCAPE_TO_ASM = 1 << 2, /* Passed by address to an assembly + statement. */ + ESCAPE_TO_CALL = 1 << 3, /* Escapes to a function call. */ + ESCAPE_BAD_CAST = 1 << 4, /* Cast from pointer to integer */ + ESCAPE_TO_RETURN = 1 << 5, /* Returned from function. */ + ESCAPE_TO_PURE_CONST = 1 << 6, /* Escapes to a pure or constant + function call. */ + ESCAPE_IS_GLOBAL = 1 << 7, /* Is a global variable. */ + ESCAPE_IS_PARM = 1 << 8, /* Is an incoming function argument. */ + ESCAPE_UNKNOWN = 1 << 9 /* We believe it escapes for + some reason not enumerated + above. */ +}; /* In tree-flow-inline.h */ -static inline bool is_call_clobbered (tree); -static inline void mark_call_clobbered (tree); +static inline bool is_call_clobbered (const_tree); +static inline void mark_call_clobbered (tree, unsigned int); static inline void set_is_used (tree); -static inline bool unmodifiable_var_p (tree); +static inline bool unmodifiable_var_p (const_tree); /* In tree-eh.c */ extern void make_eh_edges (tree); 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_internal (const_tree); extern bool tree_can_throw_external (tree); -extern int lookup_stmt_eh_region (tree); +extern int lookup_stmt_eh_region (const_tree); extern void add_stmt_to_eh_region (tree, int); extern bool remove_stmt_from_eh_region (tree); extern bool maybe_clean_or_replace_eh_stmt (tree, tree); @@ -774,18 +1080,20 @@ void print_value_expressions (FILE *, tree); /* In tree-vn.c */ +tree make_value_handle (tree); +void set_value_handle (tree, tree); bool expressions_equal_p (tree, tree); -tree get_value_handle (tree); -hashval_t vn_compute (tree, hashval_t); +static inline tree get_value_handle (tree); void sort_vuses (VEC (tree, gc) *); -tree vn_lookup_or_add (tree, tree); +void sort_vuses_heap (VEC (tree, heap) *); +tree vn_lookup_or_add (tree); +tree vn_lookup_or_add_with_stmt (tree, tree); tree vn_lookup_or_add_with_vuses (tree, VEC (tree, gc) *); void vn_add (tree, tree); void vn_add_with_vuses (tree, tree, VEC (tree, gc) *); -tree vn_lookup (tree, tree); +tree vn_lookup_with_stmt (tree, tree); +tree vn_lookup (tree); tree vn_lookup_with_vuses (tree, VEC (tree, gc) *); -void vn_init (void); -void vn_delete (void); /* In tree-ssa-sink.c */ bool is_hidden_global_store (tree); @@ -798,19 +1106,24 @@ 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 *); +extern void linear_transform_loops (void); + +/* In tree-data-ref.c */ +extern void tree_check_data_deps (void); /* In tree-ssa-loop-ivopts.c */ bool expr_invariant_in_loop_p (struct loop *, tree); -bool multiplier_allowed_in_address_p (HOST_WIDE_INT); +bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode); unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode); /* In tree-ssa-threadupdate.c. */ -extern bool thread_through_all_blocks (bitmap); +extern bool thread_through_all_blocks (bool); +extern void register_jump_thread (edge, edge); /* In gimplify.c */ tree force_gimple_operand (tree, tree *, bool, tree); -tree force_gimple_operand_bsi (block_stmt_iterator *, tree, bool, tree); +tree force_gimple_operand_bsi (block_stmt_iterator *, tree, bool, tree, + bool, enum bsi_iterator_update); /* In tree-ssa-structalias.c */ bool find_what_p_points_to (tree); @@ -820,33 +1133,6 @@ extern void remove_unused_locals (void); /* 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 @@ -854,11 +1140,13 @@ struct mem_address tree symbol, base, index, step, offset; }; +struct affine_tree_combination; 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 @@ -870,20 +1158,24 @@ struct fieldoff tree size; tree decl; HOST_WIDE_INT offset; + alias_set_type alias_set; }; 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 *); + HOST_WIDE_INT, bool *, tree); void sort_fieldstack (VEC(fieldoff_s,heap) *); void init_alias_heapvars (void); void delete_alias_heapvars (void); +unsigned int execute_fixup_cfg (void); #include "tree-flow-inline.h" void swap_tree_operands (tree, tree *, tree *); +int least_common_multiple (int, int); + #endif /* _TREE_FLOW_H */