* 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

1 files changed, 21 insertions, 30 deletions

diff --git a/gcc/tree-vect-transform.c b/gcc/tree-vect-transform.c
index c2a8f0d9dc4..9dab8bcda4b 100644
--- a/gcc/tree-vect-transform.c
+++ b/gcc/tree-vect-transform.c
@@ -189,8 +189,7 @@ vect_create_addr_base_for_vector_ref (tree stmt,
 {
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
   struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info);
-  tree data_ref_base = 
-    unshare_expr (STMT_VINFO_VECT_DR_BASE_ADDRESS (stmt_info));
+  tree data_ref_base = unshare_expr (DR_BASE_ADDRESS (dr));
   tree base_name = build_fold_indirect_ref (data_ref_base);
   tree ref = DR_REF (dr);
   tree scalar_type = TREE_TYPE (ref);
@@ -199,9 +198,11 @@ vect_create_addr_base_for_vector_ref (tree stmt,
   tree new_temp;
   tree addr_base, addr_expr;
   tree dest, new_stmt;
-  tree base_offset = unshare_expr (STMT_VINFO_VECT_INIT_OFFSET (stmt_info));
+  tree base_offset = unshare_expr (DR_OFFSET (dr));
+  tree init = unshare_expr (DR_INIT (dr));
 
   /* Create base_offset */
+  base_offset = size_binop (PLUS_EXPR, base_offset, init);
   dest = create_tmp_var (TREE_TYPE (base_offset), "base_off");
   add_referenced_tmp_var (dest);
   base_offset = force_gimple_operand (base_offset, &new_stmt, false, dest);  
@@ -212,7 +213,7 @@ vect_create_addr_base_for_vector_ref (tree stmt,
       tree tmp = create_tmp_var (TREE_TYPE (base_offset), "offset");
       add_referenced_tmp_var (tmp);
       offset = fold_build2 (MULT_EXPR, TREE_TYPE (offset), offset,
-			    STMT_VINFO_VECT_STEP (stmt_info));
+			    DR_STEP (dr));
       base_offset = fold_build2 (PLUS_EXPR, TREE_TYPE (base_offset),
 				 base_offset, offset);
       base_offset = force_gimple_operand (base_offset, &new_stmt, false, tmp);  
@@ -328,9 +329,9 @@ vect_create_data_ref_ptr (tree stmt, block_stmt_iterator *bsi, tree offset,
   tree ptr_update;
   tree data_ref_ptr;
   tree type, tmp, size;
+  struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info);
 
-  base_name =  build_fold_indirect_ref (unshare_expr (
-		      STMT_VINFO_VECT_DR_BASE_ADDRESS (stmt_info)));
+  base_name =  build_fold_indirect_ref (unshare_expr (DR_BASE_ADDRESS (dr)));
 
   if (vect_print_dump_info (REPORT_DETAILS))
     {
@@ -357,9 +358,9 @@ vect_create_data_ref_ptr (tree stmt, block_stmt_iterator *bsi, tree offset,
   
   
   /** (2) Add aliasing information to the new vector-pointer:
-          (The points-to info (SSA_NAME_PTR_INFO) may be defined later.)  **/
+          (The points-to info (DR_PTR_INFO) may be defined later.)  **/
   
-  tag = STMT_VINFO_MEMTAG (stmt_info);
+  tag = DR_MEMTAG (dr);
   gcc_assert (tag);
 
   /* If tag is a variable (and NOT_A_TAG) than a new type alias
@@ -369,7 +370,7 @@ vect_create_data_ref_ptr (tree stmt, block_stmt_iterator *bsi, tree offset,
   else
     var_ann (vect_ptr)->type_mem_tag = tag;
 
-  var_ann (vect_ptr)->subvars = STMT_VINFO_SUBVARS (stmt_info);
+  var_ann (vect_ptr)->subvars = DR_SUBVARS (dr);
 
   /** (3) Calculate the initial address the vector-pointer, and set
           the vector-pointer to point to it before the loop:  **/
@@ -397,9 +398,8 @@ vect_create_data_ref_ptr (tree stmt, block_stmt_iterator *bsi, tree offset,
   if (only_init) /* No update in loop is required.  */
     {
       /* Copy the points-to information if it exists. */
-      if (STMT_VINFO_PTR_INFO (stmt_info))
-        duplicate_ssa_name_ptr_info (vect_ptr_init,
-                                     STMT_VINFO_PTR_INFO (stmt_info));
+      if (DR_PTR_INFO (dr))
+        duplicate_ssa_name_ptr_info (vect_ptr_init, DR_PTR_INFO (dr));
       return vect_ptr_init;
     }
 
@@ -433,8 +433,8 @@ vect_create_data_ref_ptr (tree stmt, block_stmt_iterator *bsi, tree offset,
   data_ref_ptr = TREE_OPERAND (vec_stmt, 0);
 
   /* Copy the points-to information if it exists. */
-  if (STMT_VINFO_PTR_INFO (stmt_info))
-    duplicate_ssa_name_ptr_info (data_ref_ptr, STMT_VINFO_PTR_INFO (stmt_info));
+  if (DR_PTR_INFO (dr))
+    duplicate_ssa_name_ptr_info (data_ref_ptr, DR_PTR_INFO (dr));
   return data_ref_ptr;
 }
 
@@ -2625,18 +2625,16 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loop_vinfo, tree loop_niters)
    NITERS iterations were peeled from LOOP.  DR represents a data reference
    in LOOP.  This function updates the information recorded in DR to
    account for the fact that the first NITERS iterations had already been 
-   executed.  Specifically, it updates the OFFSET field of stmt_info.  */
+   executed.  Specifically, it updates the OFFSET field of DR.  */
 
 static void
 vect_update_init_of_dr (struct data_reference *dr, tree niters)
 {
-  stmt_vec_info stmt_info = vinfo_for_stmt (DR_STMT (dr));
-  tree offset = STMT_VINFO_VECT_INIT_OFFSET (stmt_info);
+  tree offset = DR_OFFSET (dr);
       
-  niters = fold_build2 (MULT_EXPR, TREE_TYPE (niters), niters,
-			STMT_VINFO_VECT_STEP (stmt_info));
+  niters = fold_build2 (MULT_EXPR, TREE_TYPE (niters), niters, DR_STEP (dr));
   offset = fold_build2 (PLUS_EXPR, TREE_TYPE (offset), offset, niters);
-  STMT_VINFO_VECT_INIT_OFFSET (stmt_info) = offset;
+  DR_OFFSET (dr) = offset;
 }
 
 
@@ -2652,21 +2650,14 @@ static void
 vect_update_inits_of_drs (loop_vec_info loop_vinfo, tree niters)
 {
   unsigned int i;
-  varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo);
-  varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo);
+  varray_type datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
 
   if (vect_dump && (dump_flags & TDF_DETAILS))
     fprintf (vect_dump, "=== vect_update_inits_of_dr ===");
 
-  for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
-    {
-      struct data_reference *dr = VARRAY_GENERIC_PTR (loop_write_datarefs, i);
-      vect_update_init_of_dr (dr, niters);
-    }
-
-  for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_read_datarefs); i++)
+  for (i = 0; i < VARRAY_ACTIVE_SIZE (datarefs); i++)
     {
-      struct data_reference *dr = VARRAY_GENERIC_PTR (loop_read_datarefs, i);
+      struct data_reference *dr = VARRAY_GENERIC_PTR (datarefs, i);
       vect_update_init_of_dr (dr, niters);
     }
 }