From 516849c7cdbe9be15bb886db53588d1cc868e795 Mon Sep 17 00:00:00 2001 From: irar Date: Mon, 25 Jul 2005 12:05:07 +0000 Subject: * expr.c (highest_pow2_factor): Make extern. * tree-data-ref.c (ptr_decl_may_alias_p): New function. (ptr_ptr_may_alias_p, may_alias_p, record_ptr_differ_p, record_array_differ_p, array_ptr_differ_p): Likewise. (base_object_differ_p): Rename (from array_base_name_differ_p). Support additional cases. Call the above functions. (base_addr_differ_p): Moved from tree-vect-analyze.c. Call base_object_differ_p when there are two base objects. Otherwise, compare base address and offset. Call may_alias_p. (dump_data_reference): Use a correct field name. (analyze_array): Make static. Initialize new data-ref fields. (analyze_indirect_ref): New function. (init_data_ref): Initialize new data-ref fields. (strip_conversion): Moved from tree-vect-analyze.c. (analyze_offset_expr, get_ptr_offset, address_analysis, object_analysis): Likewise. (analyze_offset): New function. (create_data_ref): Likewise. (initialize_data_dependence_relation): Call base_addr_differ_p. Compare dimensions for ARRAY_REFs only. (build_classic_dist_vector): Make static. (access_functions_are_affine_or_constant_p): Call macro to get the address of access functions. (compute_all_dependences): Add new parameter compute_self_and_read_read_dependences. Compute self and read-read dependences if it is true. (find_data_references_in_loop): Call create_data_ref. Initialize new data-ref fields. (compute_data_dependences_for_loop): Add new parameter compute_self_and_read_read_dependences. Remove parameter nb_loops, compute nb_loops. Call compute_all_dependences, build_classic_dist_vector and build_classic_dir_vector with correct parameters. (analyze_all_data_dependences): Call compute_data_dependences_for_loop with correct parameters. Compare dimensions for ARRAY_REFs only. (free_data_refs): Call macro to free access functions. * tree-data-ref.h (struct first_location_in_loop): New structure. Move fields from stmt_vinfo. (struct base_object_info): New structure. (struct data_reference): Move fields to base_object_info. Add fields first_location and object_info for above structures. Move fields from stmt_info: memtag, ptr_info, subvars, misalignment. Add new field aligned_to. Add macros to access the new fields. Update functions declarations. * tree-flow.h (is_aliased_with): Declare. * tree-loop-linear.c (linear_transform_loops): Call compute_data_dependences_for_loop with correct parameters. * tree-ssa-alias.c (is_aliased_with): New function. * tree-vect-analyze.c (vect_get_ptr_offset): Remove. (vect_analyze_offset_expr, vect_base_addr_differ_p): Likewise. (vect_analyze_data_ref_dependence): Get ddr. Remove call to vect_base_addr_differ_p, compute_subscript_distance and build_classic_dist_vector. Add printings. Check absolute value of distance. (vect_analyze_data_ref_dependences): Go through ddrs instead of data-refs. (vect_compute_data_ref_alignment): Get the fields of data-ref instead of stmt. Check aligned_to. Check if the base is aligned. Remove conversion to bytes. Add printing. (vect_compute_data_refs_alignment): Go through loads and stores in one loop. (vect_enhance_data_refs_alignment, vect_analyze_data_refs_alignment, vect_analyze_data_ref_access): Likewise. (vect_analyze_pointer_ref_access): Remove. (vect_address_analysis, vect_object_analysis): Likewise. (vect_analyze_data_refs): Call compute_data_dependences_for_loop to find and analyze data-refs in the loop. * tree-vect-transform.c (vect_create_addr_base_for_vector_ref): Get the fields of data-ref instead of stmt. Add init to the offset from the base. (vect_create_data_ref_ptr): Get the fields of data-ref instead of stmt. (vect_update_init_of_dr): Likewise. (vect_update_inits_of_drs): Go through loads and stores in one loop. * tree-vectorizer.c (new_stmt_vec_info): Remove initialization of removed fields. (new_loop_vec_info): Initialize new fields. (destroy_loop_vec_info): Free new fields. (vect_strip_conversion): Remove. * tree-vectorizer.h (enum verbosity_levels): Add new verbosity level. (struct _loop_vec_info): Unify data_ref_writes and data_ref_reads into datarefs. Add new field ddrs. Add macros for the new fields access. (struct _stmt_vec_info): Remove: base_address, initial_offset, step, base_aligned_p, misalignment, memtag, ptr_info and subvars. Remove their macros. * tree.h (highest_pow2_factor): Declare. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@102356 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/tree-data-ref.h | 124 ++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 105 insertions(+), 19 deletions(-) (limited to 'gcc/tree-data-ref.h') diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h index 49e23e43836..d0e670149d3 100644 --- a/gcc/tree-data-ref.h +++ b/gcc/tree-data-ref.h @@ -24,6 +24,50 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA #include "lambda.h" +/** {base_address + offset + init} is the first location accessed by data-ref + in the loop, and step is the stride of data-ref in the loop in bytes; + e.g.: + + Example 1 Example 2 + data-ref a[j].b[i][j] a + x + 16B (a is int*) + +First location info: + base_address &a a + offset j_0*D_j + i_0*D_i + C_a x + init C_b 16 + step D_j 4 + access_fn NULL {16, +, 1} + +Base object info: + base_object a NULL + access_fn NULL + + **/ +struct first_location_in_loop +{ + tree base_address; + tree offset; + tree init; + tree step; + /* Access function related to first location in the loop. */ + VEC(tree,heap) *access_fns; + +}; + +struct base_object_info +{ + /* The object. */ + tree base_object; + + /* A list of chrecs. Access functions related to BASE_OBJECT. */ + VEC(tree,heap) *access_fns; +}; + +enum data_ref_type { + ARRAY_REF_TYPE, + POINTER_REF_TYPE +}; + struct data_reference { /* A pointer to the statement that contains this DR. */ @@ -32,27 +76,74 @@ struct data_reference /* A pointer to the ARRAY_REF node. */ tree ref; - /* The name of the array. */ - tree base_name; - - /* A list of chrecs. */ - VEC(tree,heap) *access_fns; - /* Auxiliary info specific to a pass. */ int aux; /* True when the data reference is in RHS of a stmt. */ bool is_read; + /* First location accessed by the data-ref in the loop. */ + struct first_location_in_loop first_location; + + /* Base object related info. */ + struct base_object_info object_info; + + /* Aliasing information. This field represents the symbol that + should be aliased by a pointer holding the address of this data + reference. If the original data reference was a pointer + dereference, then this field contains the memory tag that should + be used by the new vector-pointer. */ + tree memtag; + struct ptr_info_def *ptr_info; + subvar_t subvars; + + /* Alignment information. */ + /* The offset of the data-reference from its base in bytes. */ + tree misalignment; + /* The maximum data-ref's alignment. */ + tree aligned_to; + + /* The type of the data-ref. */ + enum data_ref_type type; }; -#define DR_STMT(DR) DR->stmt -#define DR_REF(DR) DR->ref -#define DR_BASE_NAME(DR) DR->base_name -#define DR_ACCESS_FNS(DR) DR->access_fns -#define DR_ACCESS_FN(DR, I) VEC_index (tree, DR_ACCESS_FNS (DR), I) -#define DR_NUM_DIMENSIONS(DR) VEC_length (tree, DR_ACCESS_FNS (DR)) -#define DR_IS_READ(DR) DR->is_read +#define DR_STMT(DR) (DR)->stmt +#define DR_REF(DR) (DR)->ref +#define DR_BASE_OBJECT(DR) (DR)->object_info.base_object +#define DR_TYPE(DR) (DR)->type +#define DR_ACCESS_FNS(DR)\ + (DR_TYPE(DR) == ARRAY_REF_TYPE ? \ + (DR)->object_info.access_fns : (DR)->first_location.access_fns) +#define DR_ACCESS_FN(DR, I) VEC_index (tree, DR_ACCESS_FNS (DR), I) +#define DR_NUM_DIMENSIONS(DR) VEC_length (tree, DR_ACCESS_FNS (DR)) +#define DR_IS_READ(DR) (DR)->is_read +#define DR_BASE_ADDRESS(DR) (DR)->first_location.base_address +#define DR_OFFSET(DR) (DR)->first_location.offset +#define DR_INIT(DR) (DR)->first_location.init +#define DR_STEP(DR) (DR)->first_location.step +#define DR_MEMTAG(DR) (DR)->memtag +#define DR_ALIGNED_TO(DR) (DR)->aligned_to +#define DR_OFFSET_MISALIGNMENT(DR) (DR)->misalignment +#define DR_PTR_INFO(DR) (DR)->ptr_info +#define DR_SUBVARS(DR) (DR)->subvars + +#define DR_ACCESS_FNS_ADDR(DR) \ + (DR_TYPE(DR) == ARRAY_REF_TYPE ? \ + &((DR)->object_info.access_fns) : &((DR)->first_location.access_fns)) +#define DR_SET_ACCESS_FNS(DR, ACC_FNS) \ +{ \ + if (DR_TYPE(DR) == ARRAY_REF_TYPE) \ + (DR)->object_info.access_fns = ACC_FNS; \ + else \ + (DR)->first_location.access_fns = ACC_FNS; \ +} +#define DR_FREE_ACCESS_FNS(DR) \ +{ \ + if (DR_TYPE(DR) == ARRAY_REF_TYPE) \ + VEC_free (tree, heap, (DR)->object_info.access_fns); \ + else \ + VEC_free (tree, heap, (DR)->first_location.access_fns); \ +} enum data_dependence_direction { dir_positive, @@ -156,10 +247,8 @@ extern struct data_dependence_relation *initialize_data_dependence_relation (struct data_reference *, struct data_reference *); extern void compute_affine_dependence (struct data_dependence_relation *); extern void analyze_all_data_dependences (struct loops *); -extern void compute_data_dependences_for_loop (unsigned, struct loop *, +extern void compute_data_dependences_for_loop (struct loop *, bool, varray_type *, varray_type *); -extern struct data_reference * init_data_ref (tree, tree, tree, tree, bool); -extern struct data_reference *analyze_array (tree, tree, bool); extern void dump_subscript (FILE *, struct subscript *); extern void dump_ddrs (FILE *, varray_type); @@ -171,13 +260,10 @@ extern void dump_data_dependence_relation (FILE *, extern void dump_data_dependence_relations (FILE *, varray_type); extern void dump_data_dependence_direction (FILE *, enum data_dependence_direction); -extern bool array_base_name_differ_p (struct data_reference *, - struct data_reference *, bool *); extern void free_dependence_relation (struct data_dependence_relation *); extern void free_dependence_relations (varray_type); extern void free_data_refs (varray_type); extern void compute_subscript_distance (struct data_dependence_relation *); -extern bool build_classic_dist_vector (struct data_dependence_relation *, int, int); -- cgit v1.2.3