X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Ftree-flow.h;h=ded7a3f9fac6ac1269f856fe84ef97dd45f66062;hp=fb1373a1ad0a0af6c5073e11ef661db6be34e6ce;hb=612cc2ea107e0b667a4f78fa82318c2b4052a814;hpb=182cf5a9a415f31df0f9a10e46faed1221484a35 diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index fb1373a1ad0..ded7a3f9fac 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 @@ -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. */ @@ -61,7 +69,7 @@ struct GTY(()) gimple_df { 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 @@ -80,6 +88,10 @@ struct GTY(()) gimple_df { 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 @@ -119,6 +131,18 @@ struct GTY(()) ptr_info_def { /* 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; }; @@ -160,10 +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; - /* Used by var_map for the base index of ssa base variables. */ unsigned base_index; @@ -270,20 +290,9 @@ typedef struct immediate_use_iterator_d 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); @@ -291,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; }; @@ -313,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))) @@ -368,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; @@ -426,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, @@ -439,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, @@ -515,13 +522,13 @@ extern void record_vars_into (tree, tree); extern void record_vars (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. */ @@ -546,9 +553,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 warn_uninit (tree, const char *, void *); +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 (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. */ @@ -558,6 +565,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 */ @@ -593,12 +601,14 @@ extern void ssanames_print_statistics (void); /* In tree-ssa-ccp.c */ tree fold_const_aggregate_ref (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); @@ -673,7 +683,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); @@ -701,8 +711,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 *); @@ -719,6 +727,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 */ @@ -780,6 +789,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; @@ -806,13 +816,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); @@ -834,7 +849,7 @@ 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); @@ -846,10 +861,11 @@ 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 */