--- a/gcc/tree-vectorizer.h	Sun Feb 07 18:28:00 2010 +0900
+++ b/gcc/tree-vectorizer.h	Fri Feb 12 23:39:51 2010 +0900
@@ -1,5 +1,6 @@
-/* Loop Vectorization
-   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+/* Vectorizer
+   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free
+   Software Foundation, Inc.
    Contributed by Dorit Naishlos <dorit@il.ibm.com>
 
 This file is part of GCC.
@@ -21,6 +22,8 @@
 #ifndef GCC_TREE_VECTORIZER_H
 #define GCC_TREE_VECTORIZER_H
 
+#include "tree-data-ref.h"
+
 typedef source_location LOC;
 #define UNKNOWN_LOC UNKNOWN_LOCATION
 #define EXPR_LOC(e) EXPR_LOCATION(e)
@@ -52,19 +55,22 @@
 
 /* Define type of def-use cross-iteration cycle.  */
 enum vect_def_type {
+  vect_uninitialized_def = 0,
   vect_constant_def = 1,
-  vect_invariant_def,
-  vect_loop_def,
+  vect_external_def,
+  vect_internal_def,
   vect_induction_def,
   vect_reduction_def,
+  vect_double_reduction_def,
+  vect_nested_cycle,
   vect_unknown_def_type
 };
 
 /* Define verbosity levels.  */
 enum verbosity_levels {
   REPORT_NONE,
-  REPORT_VECTORIZED_LOOPS,
-  REPORT_UNVECTORIZED_LOOPS,
+  REPORT_VECTORIZED_LOCATIONS,
+  REPORT_UNVECTORIZED_LOCATIONS,
   REPORT_COST,
   REPORT_ALIGNMENT,
   REPORT_DR_DETAILS,
@@ -92,9 +98,9 @@
   VEC (gimple, heap) *stmts;
   /* Vectorized stmt/s.  */
   VEC (gimple, heap) *vec_stmts;
-  /* Number of vector stmts that are created to replace the group of scalar 
-     stmts. It is calculated during the transformation phase as the number of 
-     scalar elements in one scalar iteration (GROUP_SIZE) multiplied by VF 
+  /* Number of vector stmts that are created to replace the group of scalar
+     stmts. It is calculated during the transformation phase as the number of
+     scalar elements in one scalar iteration (GROUP_SIZE) multiplied by VF
      divided by vector size.  */
   unsigned int vec_stmts_size;
   /* Vectorization costs associated with SLP node.  */
@@ -121,13 +127,13 @@
   unsigned int unrolling_factor;
 
   /* Vectorization costs associated with SLP instance.  */
-  struct  
+  struct
   {
     int outside_of_loop;     /* Statements generated outside loop.  */
     int inside_of_loop;      /* Statements generated inside loop.  */
   } cost;
 
-  /* Loads permutation relatively to the stores, NULL if there is no 
+  /* Loads permutation relatively to the stores, NULL if there is no
      permutation.  */
   VEC (int, heap) *load_permutation;
 
@@ -176,12 +182,12 @@
   tree num_iters_unchanged;
 
   /* Minimum number of iterations below which vectorization is expected to
-     not be profitable (as estimated by the cost model). 
+     not be profitable (as estimated by the cost model).
      -1 indicates that vectorization will not be profitable.
      FORNOW: This field is an int. Will be a tree in the future, to represent
-	     values unknown at compile time.  */ 
-  int min_profitable_iters;  
-  
+	     values unknown at compile time.  */
+  int min_profitable_iters;
+
   /* Is the loop vectorizable? */
   bool vectorizable;
 
@@ -229,39 +235,44 @@
      of the loop.  */
   VEC(slp_instance, heap) *slp_instances;
 
-  /* The unrolling factor needed to SLP the loop. In case of that pure SLP is 
+  /* The unrolling factor needed to SLP the loop. In case of that pure SLP is
      applied to the loop, i.e., no unrolling is needed, this is 1.  */
   unsigned slp_unrolling_factor;
 } *loop_vec_info;
 
 /* Access Functions.  */
-#define LOOP_VINFO_LOOP(L)            (L)->loop
-#define LOOP_VINFO_BBS(L)             (L)->bbs
-#define LOOP_VINFO_NITERS(L)          (L)->num_iters
+#define LOOP_VINFO_LOOP(L)                 (L)->loop
+#define LOOP_VINFO_BBS(L)                  (L)->bbs
+#define LOOP_VINFO_NITERS(L)               (L)->num_iters
 /* Since LOOP_VINFO_NITERS can change after prologue peeling
    retain total unchanged scalar loop iterations for cost model.  */
-#define LOOP_VINFO_NITERS_UNCHANGED(L)          (L)->num_iters_unchanged
-#define LOOP_VINFO_COST_MODEL_MIN_ITERS(L)	(L)->min_profitable_iters
-#define LOOP_VINFO_VECTORIZABLE_P(L)  (L)->vectorizable
-#define LOOP_VINFO_VECT_FACTOR(L)     (L)->vectorization_factor
-#define LOOP_VINFO_PTR_MASK(L)        (L)->ptr_mask
-#define LOOP_VINFO_DATAREFS(L)        (L)->datarefs
-#define LOOP_VINFO_DDRS(L)            (L)->ddrs
-#define LOOP_VINFO_INT_NITERS(L)      (TREE_INT_CST_LOW ((L)->num_iters))
-#define LOOP_PEELING_FOR_ALIGNMENT(L) (L)->peeling_for_alignment
-#define LOOP_VINFO_UNALIGNED_DR(L)    (L)->unaligned_dr
-#define LOOP_VINFO_MAY_MISALIGN_STMTS(L) (L)->may_misalign_stmts
-#define LOOP_VINFO_LOC(L)             (L)->loop_line_number
-#define LOOP_VINFO_MAY_ALIAS_DDRS(L)  (L)->may_alias_ddrs
-#define LOOP_VINFO_STRIDED_STORES(L)  (L)->strided_stores
-#define LOOP_VINFO_SLP_INSTANCES(L)   (L)->slp_instances
+#define LOOP_VINFO_NITERS_UNCHANGED(L)     (L)->num_iters_unchanged
+#define LOOP_VINFO_COST_MODEL_MIN_ITERS(L) (L)->min_profitable_iters
+#define LOOP_VINFO_VECTORIZABLE_P(L)       (L)->vectorizable
+#define LOOP_VINFO_VECT_FACTOR(L)          (L)->vectorization_factor
+#define LOOP_VINFO_PTR_MASK(L)             (L)->ptr_mask
+#define LOOP_VINFO_DATAREFS(L)             (L)->datarefs
+#define LOOP_VINFO_DDRS(L)                 (L)->ddrs
+#define LOOP_VINFO_INT_NITERS(L)           (TREE_INT_CST_LOW ((L)->num_iters))
+#define LOOP_PEELING_FOR_ALIGNMENT(L)      (L)->peeling_for_alignment
+#define LOOP_VINFO_UNALIGNED_DR(L)         (L)->unaligned_dr
+#define LOOP_VINFO_MAY_MISALIGN_STMTS(L)   (L)->may_misalign_stmts
+#define LOOP_VINFO_LOC(L)                  (L)->loop_line_number
+#define LOOP_VINFO_MAY_ALIAS_DDRS(L)       (L)->may_alias_ddrs
+#define LOOP_VINFO_STRIDED_STORES(L)       (L)->strided_stores
+#define LOOP_VINFO_SLP_INSTANCES(L)        (L)->slp_instances
 #define LOOP_VINFO_SLP_UNROLLING_FACTOR(L) (L)->slp_unrolling_factor
 
+#define LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT(L) \
+VEC_length (gimple, (L)->may_misalign_stmts) > 0
+#define LOOP_REQUIRES_VERSIONING_FOR_ALIAS(L)     \
+VEC_length (ddr_p, (L)->may_alias_ddrs) > 0
+
 #define NITERS_KNOWN_P(n)                     \
 (host_integerp ((n),0)                        \
 && TREE_INT_CST_LOW ((n)) > 0)
 
-#define LOOP_VINFO_NITERS_KNOWN_P(L)                     \
+#define LOOP_VINFO_NITERS_KNOWN_P(L)          \
 NITERS_KNOWN_P((L)->num_iters)
 
 static inline loop_vec_info
@@ -273,10 +284,40 @@
 static inline bool
 nested_in_vect_loop_p (struct loop *loop, gimple stmt)
 {
-  return (loop->inner 
+  return (loop->inner
           && (loop->inner == (gimple_bb (stmt))->loop_father));
 }
 
+typedef struct _bb_vec_info {
+
+  basic_block bb;
+  /* All interleaving chains of stores in the basic block, represented by the
+     first stmt in the chain.  */
+  VEC(gimple, heap) *strided_stores;
+
+  /* All SLP instances in the basic block. This is a subset of the set of
+     STRIDED_STORES of the basic block.  */
+  VEC(slp_instance, heap) *slp_instances;
+
+  /* All data references in the basic block.  */
+  VEC (data_reference_p, heap) *datarefs;
+
+  /* All data dependences in the basic block.  */
+  VEC (ddr_p, heap) *ddrs;
+} *bb_vec_info;
+
+#define BB_VINFO_BB(B)              (B)->bb
+#define BB_VINFO_STRIDED_STORES(B)  (B)->strided_stores
+#define BB_VINFO_SLP_INSTANCES(B)   (B)->slp_instances
+#define BB_VINFO_DATAREFS(B)        (B)->datarefs
+#define BB_VINFO_DDRS(B)            (B)->ddrs
+
+static inline bb_vec_info
+vec_info_for_bb (basic_block bb)
+{
+  return (bb_vec_info) bb->aux;
+}
+
 /*-----------------------------------------------------------------*/
 /* Info on vectorized defs.                                        */
 /*-----------------------------------------------------------------*/
@@ -296,40 +337,45 @@
   loop_exit_ctrl_vec_info_type
 };
 
-/* Indicates whether/how a variable is used in the loop.  */
+/* Indicates whether/how a variable is used in the scope of loop/basic
+   block.  */
 enum vect_relevant {
-  vect_unused_in_loop = 0,
+  vect_unused_in_scope = 0,
+  /* The def is in the inner loop, and the use is in the outer loop, and the
+     use is a reduction stmt.  */
   vect_used_in_outer_by_reduction,
+  /* The def is in the inner loop, and the use is in the outer loop (and is
+     not part of reduction).  */
   vect_used_in_outer,
 
   /* defs that feed computations that end up (only) in a reduction. These
-     defs may be used by non-reduction stmts, but eventually, any 
-     computations/values that are affected by these defs are used to compute 
-     a reduction (i.e. don't get stored to memory, for example). We use this 
-     to identify computations that we can change the order in which they are 
+     defs may be used by non-reduction stmts, but eventually, any
+     computations/values that are affected by these defs are used to compute
+     a reduction (i.e. don't get stored to memory, for example). We use this
+     to identify computations that we can change the order in which they are
      computed.  */
   vect_used_by_reduction,
 
-  vect_used_in_loop  
+  vect_used_in_scope
 };
 
 /* The type of vectorization that can be applied to the stmt: regular loop-based
    vectorization; pure SLP - the stmt is a part of SLP instances and does not
    have uses outside SLP instances; or hybrid SLP and loop-based - the stmt is
    a part of SLP instance and also must be loop-based vectorized, since it has
-   uses outside SLP sequences. 
+   uses outside SLP sequences.
 
-   In the loop context the meanings of pure and hybrid SLP are slightly 
-   different. By saying that pure SLP is applied to the loop, we mean that we 
-   exploit only intra-iteration parallelism in the loop; i.e., the loop can be 
-   vectorized without doing any conceptual unrolling, cause we don't pack 
-   together stmts from different iterations, only within a single iteration. 
-   Loop hybrid SLP means that we exploit both intra-iteration and 
+   In the loop context the meanings of pure and hybrid SLP are slightly
+   different. By saying that pure SLP is applied to the loop, we mean that we
+   exploit only intra-iteration parallelism in the loop; i.e., the loop can be
+   vectorized without doing any conceptual unrolling, cause we don't pack
+   together stmts from different iterations, only within a single iteration.
+   Loop hybrid SLP means that we exploit both intra-iteration and
    inter-iteration parallelism (e.g., number of elements in the vector is 4
-   and the slp-group-size is 2, in which case we don't have enough parallelism 
-   within an iteration, so we obtain the rest of the parallelism from subsequent 
+   and the slp-group-size is 2, in which case we don't have enough parallelism
+   within an iteration, so we obtain the rest of the parallelism from subsequent
    iterations by unrolling the loop by 2).  */
-enum slp_vect_type { 
+enum slp_vect_type {
   loop_vect = 0,
   pure_slp,
   hybrid
@@ -367,7 +413,7 @@
 
 
   /** The following is relevant only for stmts that contain a non-scalar
-     data-ref (array/pointer/struct access). A GIMPLE stmt is expected to have 
+     data-ref (array/pointer/struct access). A GIMPLE stmt is expected to have
      at most one such data-ref.  **/
 
   /* Information about the data-ref (access function, etc),
@@ -385,14 +431,14 @@
   /* Stmt is part of some pattern (computation idiom)  */
   bool in_pattern_p;
 
-  /* Used for various bookkeeping purposes, generally holding a pointer to 
-     some other stmt S that is in some way "related" to this stmt. 
+  /* Used for various bookkeeping purposes, generally holding a pointer to
+     some other stmt S that is in some way "related" to this stmt.
      Current use of this field is:
-        If this stmt is part of a pattern (i.e. the field 'in_pattern_p' is 
-        true): S is the "pattern stmt" that represents (and replaces) the 
-        sequence of stmts that constitutes the pattern.  Similarly, the 
-        related_stmt of the "pattern stmt" points back to this stmt (which is 
-        the last stmt in the original sequence of stmts that constitutes the 
+        If this stmt is part of a pattern (i.e. the field 'in_pattern_p' is
+        true): S is the "pattern stmt" that represents (and replaces) the
+        sequence of stmts that constitutes the pattern.  Similarly, the
+        related_stmt of the "pattern stmt" points back to this stmt (which is
+        the last stmt in the original sequence of stmts that constitutes the
         pattern).  */
   gimple related_stmt;
 
@@ -424,7 +470,7 @@
   bool read_write_dep;
 
   /* Vectorization costs associated with statement.  */
-  struct  
+  struct
   {
     int outside_of_loop;     /* Statements generated outside loop.  */
     int inside_of_loop;      /* Statements generated inside loop.  */
@@ -432,12 +478,16 @@
 
   /*  Whether the stmt is SLPed, loop-based vectorized, or both.  */
   enum slp_vect_type slp_type;
+
+  /* The bb_vec_info with respect to which STMT is vectorized.  */
+  bb_vec_info bb_vinfo;
 } *stmt_vec_info;
 
 /* Access Functions.  */
 #define STMT_VINFO_TYPE(S)                 (S)->type
 #define STMT_VINFO_STMT(S)                 (S)->stmt
 #define STMT_VINFO_LOOP_VINFO(S)           (S)->loop_vinfo
+#define STMT_VINFO_BB_VINFO(S)             (S)->bb_vinfo
 #define STMT_VINFO_RELEVANT(S)             (S)->relevant
 #define STMT_VINFO_LIVE_P(S)               (S)->live
 #define STMT_VINFO_VECTYPE(S)              (S)->vectype
@@ -471,7 +521,7 @@
 #define DR_GROUP_SAME_DR_STMT(S)           (S)->same_dr_stmt
 #define DR_GROUP_READ_WRITE_DEPENDENCE(S)  (S)->read_write_dep
 
-#define STMT_VINFO_RELEVANT_P(S)          ((S)->relevant != vect_unused_in_loop)
+#define STMT_VINFO_RELEVANT_P(S)          ((S)->relevant != vect_unused_in_scope)
 #define STMT_VINFO_OUTSIDE_OF_LOOP_COST(S) (S)->cost.outside_of_loop
 #define STMT_VINFO_INSIDE_OF_LOOP_COST(S)  (S)->cost.inside_of_loop
 
@@ -508,7 +558,7 @@
 #endif
 
 /* Cost of any vector operation, excluding load, store or vector to scalar
-   operation.  */ 
+   operation.  */
 #ifndef TARG_VEC_STMT_COST
 #define TARG_VEC_STMT_COST           1
 #endif
@@ -633,25 +683,25 @@
   return false;
 }
 
-static inline void 
-stmt_vinfo_set_inside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node, 
+static inline void
+stmt_vinfo_set_inside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node,
 				    int cost)
 {
   if (slp_node)
     SLP_TREE_INSIDE_OF_LOOP_COST (slp_node) = cost;
   else
     STMT_VINFO_INSIDE_OF_LOOP_COST (stmt_info) = cost;
-}     
+}
 
-static inline void 
-stmt_vinfo_set_outside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node, 
+static inline void
+stmt_vinfo_set_outside_of_loop_cost (stmt_vec_info stmt_info, slp_tree slp_node,
 				     int cost)
 {
   if (slp_node)
     SLP_TREE_OUTSIDE_OF_LOOP_COST (slp_node) = cost;
   else
     STMT_VINFO_OUTSIDE_OF_LOOP_COST (stmt_info) = cost;
-}     
+}
 
 static inline int
 vect_pow2 (int x)
@@ -687,72 +737,126 @@
 
 /* vect_dump will be set to stderr or dump_file if exist.  */
 extern FILE *vect_dump;
-extern enum verbosity_levels vect_verbosity_level;
-
-/* Bitmap of virtual variables to be renamed.  */
-extern bitmap vect_memsyms_to_rename;
+extern LOC vect_loop_location;
 
 /*-----------------------------------------------------------------*/
 /* Function prototypes.                                            */
 /*-----------------------------------------------------------------*/
 
-/*************************************************************************
-  Simple Loop Peeling Utilities - in tree-vectorizer.c
- *************************************************************************/
-/* Entry point for peeling of simple loops.
-   Peel the first/last iterations of a loop.
-   It can be used outside of the vectorizer for loops that are simple enough
-   (see function documentation).  In the vectorizer it is used to peel the
-   last few iterations when the loop bound is unknown or does not evenly
-   divide by the vectorization factor, and to peel the first few iterations
-   to force the alignment of data references in the loop.  */
-extern struct loop *slpeel_tree_peel_loop_to_edge 
-  (struct loop *, edge, tree, tree, bool, unsigned int, bool);
-extern void set_prologue_iterations (basic_block, tree,
-				     struct loop *, unsigned int);
-struct loop *tree_duplicate_loop_on_edge (struct loop *, edge);
+/* Simple loop peeling and versioning utilities for vectorizer's purposes -
+   in tree-vect-loop-manip.c.  */
 extern void slpeel_make_loop_iterate_ntimes (struct loop *, tree);
 extern bool slpeel_can_duplicate_loop_p (const struct loop *, const_edge);
-#ifdef ENABLE_CHECKING
-extern void slpeel_verify_cfg_after_peeling (struct loop *, struct loop *);
-#endif
+extern void vect_loop_versioning (loop_vec_info, bool, tree *, gimple_seq *);
+extern void vect_do_peeling_for_loop_bound (loop_vec_info, tree *,
+                                            tree, gimple_seq);
+extern void vect_do_peeling_for_alignment (loop_vec_info);
+extern LOC find_loop_location (struct loop *);
+extern bool vect_can_advance_ivs_p (loop_vec_info);
+
+/* In tree-vect-stmts.c.  */
+extern tree get_vectype_for_scalar_type (tree);
+extern bool vect_is_simple_use (tree, loop_vec_info, bb_vec_info, gimple *,
+                                tree *,  enum vect_def_type *);
+extern bool supportable_widening_operation (enum tree_code, gimple, tree,
+                                            tree *, tree *, enum tree_code *,
+                                            enum tree_code *, int *,
+                                            VEC (tree, heap) **);
+extern bool supportable_narrowing_operation (enum tree_code, const_gimple,
+                                             tree, enum tree_code *, int *,
+                                             VEC (tree, heap) **);
+extern stmt_vec_info new_stmt_vec_info (gimple stmt, loop_vec_info,
+                                        bb_vec_info);
+extern void free_stmt_vec_info (gimple stmt);
+extern tree vectorizable_function (gimple, tree, tree);
+extern void vect_model_simple_cost (stmt_vec_info, int, enum vect_def_type *,
+                                    slp_tree);
+extern void vect_model_store_cost (stmt_vec_info, int, enum vect_def_type,
+                                   slp_tree);
+extern void vect_model_load_cost (stmt_vec_info, int, slp_tree);
+extern void vect_finish_stmt_generation (gimple, gimple,
+                                         gimple_stmt_iterator *);
+extern bool vect_mark_stmts_to_be_vectorized (loop_vec_info);
+extern int cost_for_stmt (gimple);
+extern tree vect_get_vec_def_for_operand (tree, gimple, tree *);
+extern tree vect_init_vector (gimple, tree, tree,
+                              gimple_stmt_iterator *);
+extern tree vect_get_vec_def_for_stmt_copy (enum vect_def_type, tree);
+extern bool vect_transform_stmt (gimple, gimple_stmt_iterator *,
+                                 bool *, slp_tree, slp_instance);
+extern void vect_remove_stores (gimple);
+extern bool vect_analyze_stmt (gimple, bool *, slp_tree);
+extern bool vectorizable_condition (gimple, gimple_stmt_iterator *, gimple *,
+                                    tree, int);
+
+/* In tree-vect-data-refs.c.  */
+extern bool vect_can_force_dr_alignment_p (const_tree, unsigned int);
+extern enum dr_alignment_support vect_supportable_dr_alignment
+                                           (struct data_reference *);
+extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *,
+                                           HOST_WIDE_INT *);
+extern bool vect_analyze_data_ref_dependences (loop_vec_info, bb_vec_info);
+extern bool vect_enhance_data_refs_alignment (loop_vec_info);
+extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info);
+extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info);
+extern bool vect_analyze_data_ref_accesses (loop_vec_info, bb_vec_info);
+extern bool vect_prune_runtime_alias_test_list (loop_vec_info);
+extern bool vect_analyze_data_refs (loop_vec_info, bb_vec_info);
+extern tree vect_create_data_ref_ptr (gimple, struct loop *, tree, tree *,
+                                      gimple *, bool, bool *);
+extern tree bump_vector_ptr (tree, gimple, gimple_stmt_iterator *, gimple, tree);
+extern tree vect_create_destination_var (tree, tree);
+extern bool vect_strided_store_supported (tree);
+extern bool vect_strided_load_supported (tree);
+extern bool vect_permute_store_chain (VEC(tree,heap) *,unsigned int, gimple,
+                                    gimple_stmt_iterator *, VEC(tree,heap) **);
+extern tree vect_setup_realignment (gimple, gimple_stmt_iterator *, tree *,
+                                    enum dr_alignment_support, tree,
+                                    struct loop **);
+extern bool vect_permute_load_chain (VEC(tree,heap) *,unsigned int, gimple,
+                                    gimple_stmt_iterator *, VEC(tree,heap) **);
+extern bool vect_transform_strided_load (gimple, VEC(tree,heap) *, int,
+                                         gimple_stmt_iterator *);
+extern int vect_get_place_in_interleaving_chain (gimple, gimple);
+extern tree vect_get_new_vect_var (tree, enum vect_var_kind, const char *);
+extern tree vect_create_addr_base_for_vector_ref (gimple, gimple_seq *,
+                                                  tree, struct loop *);
+
+/* In tree-vect-loop.c.  */
+/* FORNOW: Used in tree-parloops.c.  */
+extern void destroy_loop_vec_info (loop_vec_info, bool);
+extern gimple vect_is_simple_reduction (loop_vec_info, gimple, bool, bool *);
+/* Drive for loop analysis stage.  */
+extern loop_vec_info vect_analyze_loop (struct loop *);
+/* Drive for loop transformation stage.  */
+extern void vect_transform_loop (loop_vec_info);
+extern loop_vec_info vect_analyze_loop_form (struct loop *);
+extern bool vectorizable_live_operation (gimple, gimple_stmt_iterator *,
+                                         gimple *);
+extern bool vectorizable_reduction (gimple, gimple_stmt_iterator *, gimple *);
+extern bool vectorizable_induction (gimple, gimple_stmt_iterator *, gimple *);
+extern int vect_estimate_min_profitable_iters (loop_vec_info);
+extern tree get_initial_def_for_reduction (gimple, tree, tree *);
+extern int vect_min_worthwhile_factor (enum tree_code);
 
 
-/*************************************************************************
-  General Vectorization Utilities
- *************************************************************************/
-/** In tree-vectorizer.c **/
-extern tree get_vectype_for_scalar_type (tree);
-extern bool vect_is_simple_use (tree, loop_vec_info, gimple *, tree *,
-				enum vect_def_type *);
-extern bool vect_is_simple_iv_evolution (unsigned, tree, tree *, tree *);
-extern gimple vect_is_simple_reduction (loop_vec_info, gimple);
-extern bool vect_can_force_dr_alignment_p (const_tree, unsigned int);
-extern enum dr_alignment_support vect_supportable_dr_alignment
-  (struct data_reference *);
-extern bool reduction_code_for_scalar_code (enum tree_code, enum tree_code *);
-extern bool supportable_widening_operation (enum tree_code, gimple, tree,
-  tree *, tree *, enum tree_code *, enum tree_code *, 
-  int *, VEC (tree, heap) **);
-extern bool supportable_narrowing_operation (enum tree_code, const_gimple,
-	     tree, enum tree_code *, int *, VEC (tree, heap) **);
+/* In tree-vect-slp.c.  */
+extern void vect_free_slp_instance (slp_instance);
+extern bool vect_transform_slp_perm_load (gimple, VEC (tree, heap) *,
+                                          gimple_stmt_iterator *, int,
+                                          slp_instance, bool);
+extern bool vect_schedule_slp (loop_vec_info, bb_vec_info);
+extern void vect_update_slp_costs_according_to_vf (loop_vec_info);
+extern bool vect_analyze_slp (loop_vec_info, bb_vec_info);
+extern void vect_make_slp_decision (loop_vec_info);
+extern void vect_detect_hybrid_slp (loop_vec_info);
+extern void vect_get_slp_defs (slp_tree, VEC (tree,heap) **,
+                               VEC (tree,heap) **);
+extern LOC find_bb_location (basic_block);
+extern bb_vec_info vect_slp_analyze_bb (basic_block);
+extern void vect_slp_transform_bb (basic_block);
 
-/* Creation and deletion of loop and stmt info structs.  */
-extern loop_vec_info new_loop_vec_info (struct loop *loop);
-extern void destroy_loop_vec_info (loop_vec_info, bool);
-extern stmt_vec_info new_stmt_vec_info (gimple stmt, loop_vec_info);
-extern void free_stmt_vec_info (gimple stmt);
-
-
-/** In tree-vect-analyze.c  **/
-/* Driver for analysis stage.  */
-extern loop_vec_info vect_analyze_loop (struct loop *);
-extern void vect_free_slp_instance (slp_instance);
-extern loop_vec_info vect_analyze_loop_form (struct loop *);
-extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *, 
-                                           HOST_WIDE_INT *);
-
-/** In tree-vect-patterns.c  **/
+/* In tree-vect-patterns.c.  */
 /* Pattern recognition functions.
    Additional pattern recognition functions can (and will) be added
    in the future.  */
@@ -760,46 +864,9 @@
 #define NUM_PATTERNS 4
 void vect_pattern_recog (loop_vec_info);
 
-
-/** In tree-vect-transform.c  **/
-extern bool vectorizable_load (gimple, gimple_stmt_iterator *, gimple *,
-			       slp_tree, slp_instance);
-extern bool vectorizable_store (gimple, gimple_stmt_iterator *, gimple *,
-				slp_tree);
-extern bool vectorizable_operation (gimple, gimple_stmt_iterator *, gimple *,
-				    slp_tree);
-extern bool vectorizable_type_promotion (gimple, gimple_stmt_iterator *,
-					 gimple *, slp_tree);
-extern bool vectorizable_type_demotion (gimple, gimple_stmt_iterator *,
-					gimple *, slp_tree);
-extern bool vectorizable_conversion (gimple, gimple_stmt_iterator *, gimple *,
-				     slp_tree);
-extern bool vectorizable_assignment (gimple, gimple_stmt_iterator *, gimple *,
-				     slp_tree);
-extern tree vectorizable_function (gimple, tree, tree);
-extern bool vectorizable_call (gimple, gimple_stmt_iterator *, gimple *);
-extern bool vectorizable_condition (gimple, gimple_stmt_iterator *, gimple *);
-extern bool vectorizable_live_operation (gimple, gimple_stmt_iterator *,
-					 gimple *);
-extern bool vectorizable_reduction (gimple, gimple_stmt_iterator *, gimple *);
-extern bool vectorizable_induction (gimple, gimple_stmt_iterator *, gimple *);
-extern int  vect_estimate_min_profitable_iters (loop_vec_info);
-extern void vect_model_simple_cost (stmt_vec_info, int, enum vect_def_type *, 
-				    slp_tree);
-extern void vect_model_store_cost (stmt_vec_info, int, enum vect_def_type, 
-				   slp_tree);
-extern void vect_model_load_cost (stmt_vec_info, int, slp_tree);
-extern bool vect_transform_slp_perm_load (gimple, VEC (tree, heap) *, 
-                             gimple_stmt_iterator *, int, slp_instance, bool);
-
-/* Driver for transformation stage.  */
-extern void vect_transform_loop (loop_vec_info);
-
-/*************************************************************************
-  Vectorization Debug Information - in tree-vectorizer.c
- *************************************************************************/
+/* In tree-vectorizer.c.  */
+unsigned vectorize_loops (void);
+/* Vectorization debug information */
 extern bool vect_print_dump_info (enum verbosity_levels);
-extern void vect_set_verbosity_level (const char *);
-extern LOC find_loop_location (struct loop *);
 
 #endif  /* GCC_TREE_VECTORIZER_H  */