X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-flow.h;h=319be2bb6184d092e45be2f53df4a6ff7bb8b0cb;hb=5c332a23387e660b2c7776558d2748f6d89d76a0;hp=6cd47e131809f213a7fda530a9a90bafbd8392a0;hpb=ca77c6ec2d25206fe9064d190e00b4abe1cf9fd9;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index 6cd47e13180..319be2bb618 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -1,5 +1,5 @@ /* Data and Control Flow Analysis for Trees. - Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 + Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. Contributed by Diego Novillo @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see #define _TREE_FLOW_H 1 #include "bitmap.h" -#include "hard-reg-set.h" +#include "sbitmap.h" #include "basic-block.h" #include "hashtab.h" #include "gimple.h" @@ -33,6 +33,14 @@ along with GCC; see the file COPYING3. If not see #include "tree-ssa-alias.h" +/* This structure is used to map a gimple statement to a label, + or list of labels to represent transaction restart. */ + +struct GTY(()) tm_restart_node { + gimple stmt; + tree label_or_list; +}; + /* 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. */ @@ -56,15 +64,12 @@ struct GTY(()) gimple_df { /* The PTA solution for the ESCAPED artificial variable. */ struct pt_solution escaped; - /* The PTA solution for the CALLUSED artificial variable. */ - struct pt_solution callused; - /* A map of decls to artificial ssa-names that point to the partition of the decl. */ struct pointer_map_t * GTY((skip(""))) decls_to_pointers; /* Free list of SSA_NAMEs. */ - tree free_ssanames; + VEC(tree,gc) *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 @@ -79,7 +84,14 @@ struct GTY(()) gimple_df { /* True if the code is in ssa form. */ unsigned int in_ssa_p : 1; + /* True if IPA points-to information was computed for this function. */ + unsigned int ipa_pta : 1; + struct ssa_operands ssa_operands; + + /* Map gimple stmt to tree label (or list of labels) for transaction + restart and abort. */ + htab_t GTY ((param_is (struct tm_restart_node))) tm_restart; }; /* Accessors for internal use only. Generic code should use abstraction @@ -114,10 +126,23 @@ typedef struct ---------------------------------------------------------------------------*/ /* Aliasing information for SSA_NAMEs representing pointer variables. */ + struct GTY(()) ptr_info_def { - /* The points-to solution, TBAA-pruned if the pointer is dereferenced. */ + /* The points-to solution. */ struct pt_solution pt; + + /* Alignment and misalignment of the pointer in bytes. Together + align and misalign specify low known bits of the pointer. + ptr & (align - 1) == misalign. */ + + /* The power-of-two byte alignment of the object this pointer + points into. This is usually DECL_ALIGN_UNIT for decls and + MALLOC_ABI_ALIGNMENT for allocated storage. */ + unsigned int align; + + /* The byte offset this pointer differs from the above alignment. */ + unsigned int misalign; }; @@ -146,29 +171,6 @@ enum need_phi_state { }; -/* 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 GTY(()) var_ann_d { /* Used when building base variable structures in a var_map. */ unsigned base_var_processed : 1; @@ -182,15 +184,6 @@ struct GTY(()) var_ann_d { states. */ ENUM_BITFIELD (need_phi_state) need_phi_state : 2; - /* True for HEAP artificial variables. These variables represent - the memory area allocated by a call to malloc. */ - unsigned is_heapvar : 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; - /* Used by var_map for the base index of ssa base variables. */ unsigned base_index; @@ -252,17 +245,17 @@ typedef struct immediate_use_iterator_d /* Use this iterator when simply looking at stmts. Adding, deleting or modifying stmts will cause this iterator to malfunction. */ -#define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR) \ +#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))) + (void) ((DEST) = next_readonly_imm_use (&(ITER)))) /* Use this iterator to visit each stmt which has a use of SSAVAR. */ #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))) + (void) ((STMT) = next_imm_use_stmt (&(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 @@ -290,27 +283,16 @@ typedef struct immediate_use_iterator_d #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))) + (void) ((DEST) = next_imm_use_on_stmt (&(ITER)))) typedef struct var_ann_d *var_ann_t; static inline var_ann_t var_ann (const_tree); -static inline var_ann_t get_var_ann (tree); static inline void update_stmt (gimple); static inline int get_lineno (const_gimple); -/*--------------------------------------------------------------------------- - Structure representing predictions in tree level. ----------------------------------------------------------------------------*/ -struct GTY((chain_next ("%h.ep_next"))) edge_prediction { - struct edge_prediction *ep_next; - edge ep_edge; - enum br_predictor ep_predictor; - int ep_probability; -}; - /* Accessors for basic block annotations. */ static inline gimple_seq phi_nodes (const_basic_block); static inline void set_phi_nodes (basic_block, gimple_seq); @@ -318,8 +300,7 @@ static inline void set_phi_nodes (basic_block, gimple_seq); /*--------------------------------------------------------------------------- Global declarations ---------------------------------------------------------------------------*/ -struct GTY(()) int_tree_map { - +struct int_tree_map { unsigned int uid; tree to; }; @@ -340,15 +321,14 @@ typedef struct to the hashtable while using this macro. Doing so may cause it to behave erratically. */ -#define FOR_EACH_REFERENCED_VAR(VAR, ITER) \ - for ((VAR) = first_referenced_var (&(ITER)); \ - !end_referenced_vars_p (&(ITER)); \ +#define FOR_EACH_REFERENCED_VAR(FN, VAR, ITER) \ + for ((VAR) = first_referenced_var ((FN), &(ITER)); \ + !end_referenced_vars_p (&(ITER)); \ (VAR) = next_referenced_var (&(ITER))) -extern tree referenced_var_lookup (unsigned int); +extern tree referenced_var_lookup (struct function *, unsigned int); 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) #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))) @@ -395,7 +375,7 @@ struct omp_region /* 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; + VEC(tree,gc) *ws_args; /* The code for the omp directive of this region. */ enum gimple_code type; @@ -453,9 +433,8 @@ extern basic_block label_to_block_fn (struct function *, tree); #define label_to_block(t) (label_to_block_fn (cfun, t)) extern void notice_special_calls (gimple); extern void clear_special_calls (void); -extern void verify_stmts (void); -extern void verify_gimple (void); -extern void verify_types_in_gimple_seq (gimple_seq); +extern void verify_gimple_in_seq (gimple_seq); +extern void verify_gimple_in_cfg (struct function *); extern tree gimple_block_label (basic_block); extern void extract_true_false_edges_from_block (basic_block, edge *, edge *); extern bool gimple_duplicate_sese_region (edge, edge, basic_block *, unsigned, @@ -466,9 +445,10 @@ extern void gather_blocks_in_sese_region (basic_block entry, basic_block exit, VEC(basic_block,heap) **bbs_p); extern void add_phi_args_after_copy_bb (basic_block); extern void add_phi_args_after_copy (basic_block *, unsigned, edge); -extern bool gimple_purge_dead_abnormal_call_edges (basic_block); extern bool gimple_purge_dead_eh_edges (basic_block); extern bool gimple_purge_all_dead_eh_edges (const_bitmap); +extern bool gimple_purge_dead_abnormal_call_edges (basic_block); +extern bool gimple_purge_all_dead_abnormal_call_edges (const_bitmap); extern tree gimplify_build1 (gimple_stmt_iterator *, enum tree_code, tree, tree); extern tree gimplify_build2 (gimple_stmt_iterator *, enum tree_code, @@ -485,7 +465,6 @@ extern void end_recording_case_labels (void); extern basic_block move_sese_region_to_fn (struct function *, basic_block, basic_block, tree); void remove_edge_and_dominated_blocks (edge); -void mark_virtual_ops_in_bb (basic_block); bool tree_node_can_be_shared (tree); /* In tree-cfgcleanup.c */ @@ -519,12 +498,12 @@ extern tree gimple_default_def (struct function *, tree); extern bool stmt_references_abnormal_ssa_name (gimple); extern tree get_ref_base_and_extent (tree, HOST_WIDE_INT *, HOST_WIDE_INT *, HOST_WIDE_INT *); +extern tree get_addr_base_and_unit_offset (tree, HOST_WIDE_INT *); extern void find_referenced_vars_in (gimple); /* In tree-phinodes.c */ extern void reserve_phi_args_for_new_edge (basic_block); extern void add_phi_node_to_bb (gimple phi, basic_block bb); -extern gimple make_phi_node (tree var, int len); extern gimple create_phi_node (tree, basic_block); extern void add_phi_arg (gimple, tree, edge, source_location); extern void remove_phi_args (edge); @@ -540,16 +519,15 @@ extern void phinodes_print_statistics (void); /* In gimple-low.c */ extern void record_vars_into (tree, tree); extern void record_vars (tree); -extern bool block_may_fallthru (const_tree); extern bool gimple_seq_may_fallthru (gimple_seq); extern bool gimple_stmt_may_fallthru (gimple); -extern bool gimple_check_call_args (gimple); +extern bool gimple_check_call_matching_types (gimple, tree); /* In tree-ssa.c */ /* Mapping for redirected edges. */ -struct GTY(()) _edge_var_map { +struct _edge_var_map { tree result; /* PHI result. */ tree def; /* PHI arg definition. */ source_location locus; /* PHI arg location. */ @@ -574,7 +552,9 @@ extern void flush_pending_stmts (edge); extern void verify_ssa (bool); extern void delete_tree_ssa (void); extern bool ssa_undefined_value_p (tree); -extern void execute_update_addresses_taken (bool); +extern void warn_uninit (enum opt_code, tree, tree, tree, const char *, void *); +extern unsigned int warn_uninitialized_vars (bool); +extern void execute_update_addresses_taken (void); /* Call-back function for walk_use_def_chains(). At each reaching definition, a function with this prototype is called. */ @@ -584,6 +564,7 @@ extern void walk_use_def_chains (tree, walk_use_def_chains_fn, void *, bool); void insert_debug_temps_for_defs (gimple_stmt_iterator *); void insert_debug_temp_for_var_def (gimple_stmt_iterator *, tree); +void reset_debug_uses (gimple); void release_defs_bitset (bitmap toremove); /* In tree-into-ssa.c */ @@ -599,6 +580,7 @@ void release_ssa_name_after_update_ssa (tree); void compute_global_livein (bitmap, bitmap); void mark_sym_for_renaming (tree); void mark_set_for_renaming (bitmap); +bool symbol_marked_for_renaming (tree); tree get_current_def (tree); void set_current_def (tree, tree); @@ -617,18 +599,15 @@ extern void ssanames_print_statistics (void); #endif /* In tree-ssa-ccp.c */ -bool fold_stmt (gimple_stmt_iterator *); -bool fold_stmt_inplace (gimple); -tree get_symbol_constant_value (tree); tree fold_const_aggregate_ref (tree); -bool may_propagate_address_into_dereference (tree, tree); - +tree gimple_fold_stmt_to_constant (gimple, tree (*)(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); tree degenerate_phi_result (gimple); +bool simple_iv_increment_p (gimple); /* In tree-ssa-copy.c */ extern void propagate_value (use_operand_p, tree); @@ -639,6 +618,9 @@ extern bool may_propagate_copy (tree, tree); extern bool may_propagate_copy_into_stmt (gimple, tree); extern bool may_propagate_copy_into_asm (tree); +/* In tree-ssa-loop-ch.c */ +bool do_while_loop_p (struct loop *); + /* Affine iv. */ typedef struct @@ -687,7 +669,7 @@ basic_block *blocks_in_phiopt_order (void); /* In tree-ssa-loop*.c */ -void tree_ssa_lim (void); +unsigned int tree_ssa_lim (void); unsigned int tree_ssa_unswitch_loops (void); unsigned int canonicalize_induction_variables (void); unsigned int tree_unroll_loops_completely (bool, bool); @@ -703,7 +685,7 @@ bool number_of_iterations_exit (struct loop *, edge, 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 (void); +void estimate_numbers_of_iterations (bool); bool array_at_struct_end_p (tree); bool scev_probably_wraps_p (tree, tree, gimple, struct loop *, bool); bool convert_affine_scev (struct loop *, tree, tree *, tree *, gimple, bool); @@ -731,8 +713,6 @@ bool gimple_duplicate_loop_to_header_edge (struct loop *, edge, struct loop *slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *, edge); void rename_variables_in_loop (struct loop *); void rename_variables_in_bb (basic_block bb); -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 *); @@ -749,6 +729,7 @@ bool stmt_dominates_stmt_p (gimple, gimple); void mark_virtual_ops_for_renaming (gimple); /* In tree-ssa-dce.c */ +void mark_virtual_operand_for_renaming (tree); void mark_virtual_phi_result_for_renaming (gimple); /* In tree-ssa-threadedge.c */ @@ -778,11 +759,9 @@ extern enum move_pos movement_possibility (gimple); char *get_lsm_tmp_name (tree, unsigned); /* In tree-flow-inline.h */ -static inline bool is_call_clobbered (const_tree); static inline void set_is_used (tree); static inline bool unmodifiable_var_p (const_tree); static inline bool ref_contains_array_ref (const_tree); -static inline bool array_ref_contains_indirect_ref (const_tree); /* In tree-eh.c */ extern void make_eh_edges (gimple); @@ -812,6 +791,7 @@ extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple, extern bool maybe_duplicate_eh_stmt (gimple, gimple); extern bool verify_eh_edges (gimple); extern bool verify_eh_dispatch_edge (gimple); +extern void maybe_remove_unreachable_handlers (void); /* In tree-ssa-pre.c */ struct pre_expr_d; @@ -838,13 +818,18 @@ bool stmt_invariant_in_loop_p (struct loop *, gimple); bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode, addr_space_t); unsigned multiply_by_cost (HOST_WIDE_INT, enum machine_mode, bool); +bool may_be_nonaddressable_p (tree expr); /* In tree-ssa-threadupdate.c. */ extern bool thread_through_all_blocks (bool); -extern void register_jump_thread (edge, edge); +extern void register_jump_thread (edge, edge, edge); /* In gimplify.c */ +tree force_gimple_operand_1 (tree, gimple_seq *, gimple_predicate, tree); tree force_gimple_operand (tree, gimple_seq *, bool, tree); +tree force_gimple_operand_gsi_1 (gimple_stmt_iterator *, tree, + gimple_predicate, tree, + bool, enum gsi_iterator_update); tree force_gimple_operand_gsi (gimple_stmt_iterator *, tree, bool, tree, bool, enum gsi_iterator_update); tree gimple_fold_indirect_ref (tree); @@ -866,18 +851,23 @@ struct mem_address struct affine_tree_combination; tree create_mem_ref (gimple_stmt_iterator *, tree, - struct affine_tree_combination *, tree, bool); + struct affine_tree_combination *, tree, tree, tree, bool); rtx addr_for_mem_ref (struct mem_address *, addr_space_t, bool); void get_address_description (tree, struct mem_address *); tree maybe_fold_tmr (tree); unsigned int execute_free_datastructures (void); unsigned int execute_fixup_cfg (void); +bool fixup_noreturn_call (gimple stmt); + +/* In ipa-pure-const.c */ +void warn_function_noreturn (tree); + +/* In tree-ssa-ter.c */ +bool stmt_is_replaceable_p (gimple); #include "tree-flow-inline.h" void swap_tree_operands (gimple, tree *, tree *); -int least_common_multiple (int, int); - #endif /* _TREE_FLOW_H */