/* 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;
/* Used when building base variable structures in a var_map. */
unsigned base_var_processed : 1;
- /* Nonzero if this variable is in the alias set of another variable. */
- unsigned is_aliased : 1;
-
/* Nonzero if this variable was used after SSA optimizations were
applied. We set this when translating out of SSA form. */
unsigned used : 1;
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;
to convert to hash table? */
tree symbol_mem_tag;
- /* Variables that may alias this variable. This may only be set on
- memory tags (NAME_MEMORY_TAG or TYPE_MEMORY_TAG). FIXME, move to
- struct tree_memory_tag. */
- VEC(tree, gc) *may_aliases;
-
/* Used when going out of SSA form to indicate which partition this
variable represents storage for. */
unsigned partition;
/* Set of variables that have had their address taken in the statement. */
bitmap addresses_taken;
- /* Nonzero if the statement references memory (at least one of its
- expressions contains a non-register operand). */
- unsigned references_memory : 1;
-
/* Unique identifier for this statement. These ID's are to be created
by each pass on an as-needed basis in any order convenient for the
pass which needs statement UIDs. */
unsigned int uid;
+ /* 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;
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 bitmap may_aliases (tree);
static inline int get_lineno (tree);
static inline const char *get_filename (tree);
static inline bool is_exec_stmt (tree);
#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 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);
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);
+extern bool cleanup_tree_cfg_loop (void);
/* In tree-pretty-print.c. */
extern void dump_generic_bb (FILE *, basic_block, int, int);
extern void debug_subvars_for (tree);
extern tree get_virtual_var (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 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 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. */
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,
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);
/* 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. */
/* 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);
void init_alias_heapvars (void);
void delete_alias_heapvars (void);
+unsigned int execute_fixup_cfg (void);
#include "tree-flow-inline.h"
OSDN Git Service
