/* 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 <dnovillo@redhat.com>
This file is part of GCC.
#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;
+};
+
+
/* 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(()) {
+struct gimple_df GTY(())
+{
/* Array of all variables referenced in the function. */
htab_t GTY((param_is (struct int_tree_map))) referenced_vars;
/* 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
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;
in the VDEF list. */
unsigned in_vdef_list : 1;
- /* True for HEAP and PARM_NOALIAS artificial variables. */
+ /* 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;
+
/* Memory partition tag assigned to this symbol. */
tree mpt;
#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 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 bool 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 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 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 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 new_type_alias (tree, tree, tree);
-extern void count_uses_and_derefs (tree, tree, unsigned *, unsigned *, bool *);
+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);
unsigned HOST_WIDE_INT,
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 walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool);
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 */
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,
/* In tree-ssa-phiopt.c */
bool empty_block_p (basic_block);
+basic_block *blocks_in_phiopt_order (void);
/* In tree-ssa-loop*.c */
unsigned int tree_ssa_prefetch_arrays (void);
unsigned int remove_empty_loops (void);
void tree_ssa_iv_optimize (void);
+void tree_predictive_commoning (void);
bool number_of_iterations_exit (struct loop *, edge,
struct tree_niter_desc *niter, bool);
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));
+ VEC(tree, heap) **, tree (*) (tree, tree));
/* In tree-ssa-loop-im.c */
/* The possibilities of statement movement. */
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
/* In tree-vn.c */
+tree make_value_handle (tree);
+void set_value_handle (tree, tree);
bool expressions_equal_p (tree, tree);
static inline tree get_value_handle (tree);
-hashval_t vn_compute (tree, hashval_t);
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);
/* In tree-loop-linear.c */
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, enum machine_mode);
unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode);
/* In tree-ssa-threadupdate.c. */
-extern bool thread_through_all_blocks (void);
+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);
tree size;
tree decl;
HOST_WIDE_INT offset;
+ HOST_WIDE_INT 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);
OSDN Git Service
