expr.c (highest_pow2_factor): Make extern.

        * 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.

From-SVN: r102356

1 files changed, 105 insertions, 19 deletions

diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h
index 49e23e4..d0e6701 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        <access_fns of indexes of b>   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);