*** tree-vectorizer.c	2005-01-19 17:40:16.000000000 -0800
--- tree-vectorizer.c.Jan19.1945	2005-01-19 17:39:10.000000000 -0800
*************** stmt_vec_info new_stmt_vec_info (tree, l
*** 272,280 ****
    Vectorization Debug Information.
   *************************************************************************/
  
  /* Utilities for output formatting. */
! static bool vect_debug_stats (LOC);
! static bool vect_debug_details (LOC);
  
  
  /*************************************************************************
--- 272,289 ----
    Vectorization Debug Information.
   *************************************************************************/
  
+ /* vect_verbosity_level set to invalid verbosity level to mark that it's 
+    uninitialized.  */ 
+ enum verbosity_levels vect_verbosity_level = MAX_VERBOSITY_LEVEL;
+ 
+ /* vect_dump will be set to stderr or dump_file if exist.  */
+ FILE *vect_dump;
+ 
  /* Utilities for output formatting. */
! static bool vect_print_dump_info (enum verbosity_levels, LOC);
! static void vect_set_dump_settings (void);
! void vect_set_verbosity_level (const char *);
! 
  
  
  /*************************************************************************
*************** slpeel_make_loop_iterate_ntimes (struct 
*** 708,716 ****
    bsi_remove (&loop_exit_bsi);
  
    loop_loc = find_loop_location (loop);
!   if (vect_debug_stats (loop_loc) 
!       || vect_debug_details (loop_loc))
!     print_generic_expr (dump_file, cond_stmt, TDF_SLIM);
  
    loop->nb_iterations = niters;
  }
--- 717,729 ----
    bsi_remove (&loop_exit_bsi);
  
    loop_loc = find_loop_location (loop);
!   if (dump_file && (dump_flags & TDF_DETAILS))
!     {
!       if (loop_loc != UNKNOWN_LOC)
!         fprintf (vect_dump, "\nloop at %s:%d: ",
!                  LOC_FILE (loop_loc), LOC_LINE (loop_loc));
!       print_generic_expr (vect_dump, cond_stmt, TDF_SLIM);
!     }
  
    loop->nb_iterations = niters;
  }
*************** slpeel_tree_duplicate_loop_to_edge_cfg (
*** 734,741 ****
    at_exit = (e == loop->exit_edges[0]); 
    if (!at_exit && e != loop_preheader_edge (loop))
      {
!       if (dump_file && (dump_flags & TDF_DETAILS))
! 	  fprintf (dump_file, "Edge is not an entry nor an exit edge.\n");
        return NULL;
      }
  
--- 747,754 ----
    at_exit = (e == loop->exit_edges[0]); 
    if (!at_exit && e != loop_preheader_edge (loop))
      {
!       if (vect_dump && (dump_flags & TDF_DETAILS))
! 	  fprintf (vect_dump, "Edge is not an entry nor an exit edge.\n");
        return NULL;
      }
  
*************** slpeel_tree_duplicate_loop_to_edge_cfg (
*** 745,753 ****
    /* Check whether duplication is possible.  */
    if (!can_copy_bbs_p (bbs, loop->num_nodes))
      {
!       if (vect_debug_stats (loop_loc) 
!           || vect_debug_details (loop_loc))
! 	fprintf (dump_file, "Cannot copy basic blocks.\n");
        free (bbs);
        return NULL;
      }
--- 758,770 ----
    /* Check whether duplication is possible.  */
    if (!can_copy_bbs_p (bbs, loop->num_nodes))
      {
!       if (dump_file && (dump_flags & TDF_DETAILS))
!         {
!           if (loop_loc != UNKNOWN_LOC)
!             fprintf (vect_dump, "\nloop at %s:%d: ",
!                      LOC_FILE (loop_loc), LOC_LINE (loop_loc));
! 	  fprintf (vect_dump, "Cannot copy basic blocks.\n");
!         }
        free (bbs);
        return NULL;
      }
*************** slpeel_tree_duplicate_loop_to_edge_cfg (
*** 756,763 ****
    new_loop = duplicate_loop (loops, loop, loop->outer);
    if (!new_loop)
      {
!       if (vect_debug_stats (loop_loc)
!           || vect_debug_details (loop_loc))
        free (bbs);
        return NULL;
      }
--- 773,780 ----
    new_loop = duplicate_loop (loops, loop, loop->outer);
    if (!new_loop)
      {
!       if (dump_file && (dump_flags & TDF_DETAILS))
!         fprintf (dump_file, "duplicate_loop returns NULL.\n");
        free (bbs);
        return NULL;
      }
*************** slpeel_tree_peel_loop_to_edge (struct lo
*** 1015,1023 ****
    if (!(new_loop = slpeel_tree_duplicate_loop_to_edge_cfg (loop, loops, e)))
      {
        loop_loc = find_loop_location (loop);
!       if (vect_debug_stats (loop_loc)
!           || vect_debug_details (loop_loc))
!         fprintf (dump_file, "tree_duplicate_loop_to_edge_cfg failed.\n");
        return NULL;
      }
    
--- 1032,1044 ----
    if (!(new_loop = slpeel_tree_duplicate_loop_to_edge_cfg (loop, loops, e)))
      {
        loop_loc = find_loop_location (loop);
!       if (dump_file && (dump_flags & TDF_DETAILS))
!         {
!           if (loop_loc != UNKNOWN_LOC)
!             fprintf (vect_dump, "\nloop at %s:%d: ",
!                      LOC_FILE (loop_loc), LOC_LINE (loop_loc));
!           fprintf (vect_dump, "tree_duplicate_loop_to_edge_cfg failed.\n");
!         }
        return NULL;
      }
    
*************** find_loop_location (struct loop *loop)
*** 1173,1178 ****
--- 1194,1274 ----
  }
  
  
+ /*************************************************************************
+   Vectorization Debug Information.
+  *************************************************************************/
+ 
+ /* Function vect_set_verbosity_level.
+ 
+    Called from toplev.c upon detection of the
+    -ftree-vectorizer-verbose=N option.  */
+ 
+ void 
+ vect_set_verbosity_level (const char *val)
+ {
+    unsigned int vl;
+ 
+    vl = atoi (val);
+    if (vl < MAX_VERBOSITY_LEVEL)
+      vect_verbosity_level = vl;
+    else
+      vect_verbosity_level = MAX_VERBOSITY_LEVEL - 1;
+ }
+ 
+ 
+ /* Function vect_set_dump_settings.
+ 
+    Fix the verbosity level of the vectorizer if the
+    requested level was not set explicitly using the flag
+    -ftree-vectorizer-verbose=N. 
+    Decide where to print the debugging information (dump_file/stderr).
+    If the user defined the verbosity level, but there is no dump file,
+    print to stderr, otherwise print to the dump file.  */
+ 
+ static void
+ vect_set_dump_settings (void)
+ {
+   vect_dump = dump_file;
+ 
+   /* Check if the verbosity level was defined by the user:  */  
+   if (vect_verbosity_level != MAX_VERBOSITY_LEVEL)
+     {
+       /* If there is no dump file, print to stderr.  */
+       if (!dump_file)
+         vect_dump = stderr; 
+       return;
+     }
+ 
+   /* User didn't specify verbosity level:  */
+   if (dump_flags & TDF_DETAILS)
+     vect_verbosity_level = REPORT_DETAILS;
+   else if (dump_flags & TDF_STATS)
+     vect_verbosity_level = REPORT_UNVECTORIZED_LOOPS;
+   else
+     vect_verbosity_level = REPORT_NONE;
+ }
+ 
+ 
+ /* Function debug_loop_details.
+ 
+    For vectorization debug dumps.  */
+ 
+ static bool
+ vect_print_dump_info (enum verbosity_levels vl, LOC loc)
+ {
+   if (vl > vect_verbosity_level)
+     return false;
+ 
+   if (loc == UNKNOWN_LOC)
+     fprintf (vect_dump, "\n");
+   else
+     fprintf (vect_dump, "\nloop at %s:%d: ",
+              LOC_FILE (loc), LOC_LINE (loc));
+ 
+   return true;
+ }
+ 
+ 
  
  /* Here the proper Vectorizer starts.  */
  
*************** destroy_loop_vec_info (loop_vec_info loo
*** 1301,1346 ****
  }
  
  
- /* Function debug_loop_stats.
- 
-    For vectorization statistics dumps.  */
- 
- static bool
- vect_debug_stats (LOC loc)
- {
-   if (!dump_file || !(dump_flags & TDF_STATS))
-     return false;
- 
-   if (loc == UNKNOWN_LOC)
-     fprintf (dump_file, "\n");
-   else
-     fprintf (dump_file, "\nloop at %s:%d: ",
-              LOC_FILE (loc), LOC_LINE (loc));
- 
-   return true;
- }
- 
- 
- /* Function debug_loop_details.
- 
-    For vectorization debug dumps.  */
- 
- static bool
- vect_debug_details (LOC loc)
- {
-   if (!dump_file || !(dump_flags & TDF_DETAILS))
-     return false;
- 
-   if (loc == UNKNOWN_LOC)
-     fprintf (dump_file, "\n");
-   else
-     fprintf (dump_file, "\nloop at %s:%d: ",
-              LOC_FILE (loc), LOC_LINE (loc));
- 
-   return true;
- }
- 
- 
  /* Function vect_get_ptr_offset
  
     Compute the OFFSET modulo vector-type alignment of pointer REF in bits.  */
--- 1397,1402 ----
*************** vect_analyze_offset_expr (tree expr, 
*** 1490,1499 ****
    if (!BINARY_CLASS_P (expr))
      {
        /* We expect to get binary expressions (PLUS/MINUS and MULT).  */
!       if (vect_debug_details (UNKNOWN_LOC))
          {
! 	  fprintf (dump_file, "Not binary expression ");
!           print_generic_expr (dump_file, expr, TDF_SLIM);
  	}
        return false;
      }
--- 1546,1555 ----
    if (!BINARY_CLASS_P (expr))
      {
        /* We expect to get binary expressions (PLUS/MINUS and MULT).  */
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
          {
! 	  fprintf (vect_dump, "Not binary expression ");
!           print_generic_expr (vect_dump, expr, TDF_SLIM);
  	}
        return false;
      }
*************** vect_get_base_and_offset (struct data_re
*** 1733,1740 ****
        /* Check that there is no remainder in bits.  */
        if (pbitpos%BITS_PER_UNIT)
  	{
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "bit offset alignment.");
  	  return NULL_TREE;
  	}
        this_offset = fold (size_binop (PLUS_EXPR, bit_pos_in_bytes, 
--- 1789,1796 ----
        /* Check that there is no remainder in bits.  */
        if (pbitpos%BITS_PER_UNIT)
  	{
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "bit offset alignment.");
  	  return NULL_TREE;
  	}
        this_offset = fold (size_binop (PLUS_EXPR, bit_pos_in_bytes, 
*************** vect_get_base_and_offset (struct data_re
*** 1763,1777 ****
        *initial_offset = fold (build2 (PLUS_EXPR, TREE_TYPE (*initial_offset), 
  				      *initial_offset, this_offset));
  
!       if (vect_debug_details (UNKNOWN_LOC))
          {
!           print_generic_expr (dump_file, expr, TDF_SLIM);
!           fprintf (dump_file, "\n --> total offset for ref: ");
!           print_generic_expr (dump_file, *initial_offset, TDF_SLIM);
!           fprintf (dump_file, "\n --> total misalign for ref: ");
!           print_generic_expr (dump_file, *misalign, TDF_SLIM);
!           fprintf (dump_file, "\n --> total step for ref: ");
!           print_generic_expr (dump_file, *step, TDF_SLIM);
          }
      }    
    return base;
--- 1819,1833 ----
        *initial_offset = fold (build2 (PLUS_EXPR, TREE_TYPE (*initial_offset), 
  				      *initial_offset, this_offset));
  
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
          {
!           print_generic_expr (vect_dump, expr, TDF_SLIM);
!           fprintf (vect_dump, "\n --> total offset for ref: ");
!           print_generic_expr (vect_dump, *initial_offset, TDF_SLIM);
!           fprintf (vect_dump, "\n --> total misalign for ref: ");
!           print_generic_expr (vect_dump, *misalign, TDF_SLIM);
!           fprintf (vect_dump, "\n --> total step for ref: ");
!           print_generic_expr (vect_dump, *step, TDF_SLIM);
          }
      }    
    return base;
*************** vect_create_addr_base_for_vector_ref (tr
*** 1979,1989 ****
    TREE_OPERAND (vec_stmt, 0) = new_temp;
    append_to_statement_list_force (vec_stmt, new_stmt_list);
  
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "created ");
!       print_generic_expr (dump_file, vec_stmt, TDF_SLIM);
!       fprintf (dump_file, "\n");
      }
    return new_temp;
  }
--- 2035,2045 ----
    TREE_OPERAND (vec_stmt, 0) = new_temp;
    append_to_statement_list_force (vec_stmt, new_stmt_list);
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "created ");
!       print_generic_expr (vect_dump, vec_stmt, TDF_SLIM);
!       fprintf (vect_dump, "\n");
      }
    return new_temp;
  }
*************** get_vectype_for_scalar_type (tree scalar
*** 2010,2028 ****
    nunits = UNITS_PER_SIMD_WORD / nbytes;
  
    vectype = build_vector_type (scalar_type, nunits);
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "get vectype with %d units of type ", nunits);
!       print_generic_expr (dump_file, scalar_type, TDF_SLIM);
      }
  
    if (!vectype)
      return NULL_TREE;
  
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "vectype: ");
!       print_generic_expr (dump_file, vectype, TDF_SLIM);
      }
  
    if (!VECTOR_MODE_P (TYPE_MODE (vectype)))
--- 2066,2084 ----
    nunits = UNITS_PER_SIMD_WORD / nbytes;
  
    vectype = build_vector_type (scalar_type, nunits);
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "get vectype with %d units of type ", nunits);
!       print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
      }
  
    if (!vectype)
      return NULL_TREE;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "vectype: ");
!       print_generic_expr (vect_dump, vectype, TDF_SLIM);
      }
  
    if (!VECTOR_MODE_P (TYPE_MODE (vectype)))
*************** get_vectype_for_scalar_type (tree scalar
*** 2030,2037 ****
        /* TODO: tree-complex.c sometimes can parallelize operations
           on generic vectors.  We can vectorize the loop in that case,
           but then we should re-run the lowering pass.  */
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "mode not supported by target.");
        return NULL_TREE;
      }
  
--- 2086,2093 ----
        /* TODO: tree-complex.c sometimes can parallelize operations
           on generic vectors.  We can vectorize the loop in that case,
           but then we should re-run the lowering pass.  */
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "mode not supported by target.");
        return NULL_TREE;
      }
  
*************** vect_create_data_ref_ptr (tree stmt, blo
*** 2134,2153 ****
    tree type, tmp, size;
  
    base_name = unshare_expr (DR_BASE_NAME (dr));
!   if (vect_debug_details (UNKNOWN_LOC))
      {
        tree data_ref_base = base_name;
!       fprintf (dump_file, "create array_ref of type: ");
!       print_generic_expr (dump_file, vectype, TDF_SLIM);
        if (TREE_CODE (data_ref_base) == VAR_DECL)
!         fprintf (dump_file, "\nvectorizing a one dimensional array ref: ");
        else if (TREE_CODE (data_ref_base) == ARRAY_REF)
!         fprintf (dump_file, "\nvectorizing a multidimensional array ref: ");
        else if (TREE_CODE (data_ref_base) == COMPONENT_REF)
!         fprintf (dump_file, "\nvectorizing a record based array ref: ");
        else if (TREE_CODE (data_ref_base) == SSA_NAME)
!         fprintf (dump_file, "\nvectorizing a pointer ref: ");
!       print_generic_expr (dump_file, base_name, TDF_SLIM);
      }
  
    /** (1) Create the new vector-pointer variable:  **/
--- 2190,2209 ----
    tree type, tmp, size;
  
    base_name = unshare_expr (DR_BASE_NAME (dr));
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
        tree data_ref_base = base_name;
!       fprintf (vect_dump, "create array_ref of type: ");
!       print_generic_expr (vect_dump, vectype, TDF_SLIM);
        if (TREE_CODE (data_ref_base) == VAR_DECL)
!         fprintf (vect_dump, "\nvectorizing a one dimensional array ref: ");
        else if (TREE_CODE (data_ref_base) == ARRAY_REF)
!         fprintf (vect_dump, "\nvectorizing a multidimensional array ref: ");
        else if (TREE_CODE (data_ref_base) == COMPONENT_REF)
!         fprintf (vect_dump, "\nvectorizing a record based array ref: ");
        else if (TREE_CODE (data_ref_base) == SSA_NAME)
!         fprintf (vect_dump, "\nvectorizing a pointer ref: ");
!       print_generic_expr (vect_dump, base_name, TDF_SLIM);
      }
  
    /** (1) Create the new vector-pointer variable:  **/
*************** vect_init_vector (tree stmt, tree vector
*** 2301,2310 ****
    new_bb = bsi_insert_on_edge_immediate (pe, init_stmt);
    gcc_assert (!new_bb);
  
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "created new init_stmt: ");
!       print_generic_expr (dump_file, init_stmt, TDF_SLIM);
      }
  
    vec_oprnd = TREE_OPERAND (init_stmt, 0);
--- 2357,2366 ----
    new_bb = bsi_insert_on_edge_immediate (pe, init_stmt);
    gcc_assert (!new_bb);
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "created new init_stmt: ");
!       print_generic_expr (vect_dump, init_stmt, TDF_SLIM);
      }
  
    vec_oprnd = TREE_OPERAND (init_stmt, 0);
*************** vect_get_vec_def_for_operand (tree op, t
*** 2341,2350 ****
    tree def;
    int i;
  
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "vect_get_vec_def_for_operand: ");
!       print_generic_expr (dump_file, op, TDF_SLIM);
      }
  
    /** ===> Case 1: operand is a constant.  **/
--- 2397,2406 ----
    tree def;
    int i;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "vect_get_vec_def_for_operand: ");
!       print_generic_expr (vect_dump, op, TDF_SLIM);
      }
  
    /** ===> Case 1: operand is a constant.  **/
*************** vect_get_vec_def_for_operand (tree op, t
*** 2356,2363 ****
        tree vec_cst;
  
        /* Build a tree with vector elements.  */
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "Create vector_cst. nunits = %d", nunits);
  
        for (i = nunits - 1; i >= 0; --i)
          {
--- 2412,2419 ----
        tree vec_cst;
  
        /* Build a tree with vector elements.  */
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "Create vector_cst. nunits = %d", nunits);
  
        for (i = nunits - 1; i >= 0; --i)
          {
*************** vect_get_vec_def_for_operand (tree op, t
*** 2374,2383 ****
    def_stmt = SSA_NAME_DEF_STMT (op);
    def_stmt_info = vinfo_for_stmt (def_stmt);
  
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "vect_get_vec_def_for_operand: def_stmt: ");
!       print_generic_expr (dump_file, def_stmt, TDF_SLIM);
      }
  
  
--- 2430,2439 ----
    def_stmt = SSA_NAME_DEF_STMT (op);
    def_stmt_info = vinfo_for_stmt (def_stmt);
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "vect_get_vec_def_for_operand: def_stmt: ");
!       print_generic_expr (vect_dump, def_stmt, TDF_SLIM);
      }
  
  
*************** vect_get_vec_def_for_operand (tree op, t
*** 2400,2407 ****
    bb = bb_for_stmt (def_stmt);
    if (TREE_CODE (def_stmt) == PHI_NODE && flow_bb_inside_loop_p (loop, bb))
      {
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "reduction/induction - unsupported.");
        internal_error ("no support for reduction/induction"); /* FORNOW */
      }
  
--- 2456,2463 ----
    bb = bb_for_stmt (def_stmt);
    if (TREE_CODE (def_stmt) == PHI_NODE && flow_bb_inside_loop_p (loop, bb))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "reduction/induction - unsupported.");
        internal_error ("no support for reduction/induction"); /* FORNOW */
      }
  
*************** vect_get_vec_def_for_operand (tree op, t
*** 2423,2440 ****
        def = op;
        break;
      default:
!       if (vect_debug_details (UNKNOWN_LOC))
  	{
!           fprintf (dump_file, "unsupported defining stmt: ");
! 	  print_generic_expr (dump_file, def_stmt, TDF_SLIM);
  	}
        internal_error ("unsupported defining stmt");
      }
  
!   /* Build a tree with vector elements. Create 'vec_inv = {inv,inv,..,inv}'  */
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "Create vector_inv.");
  
    for (i = nunits - 1; i >= 0; --i)
      {
--- 2479,2497 ----
        def = op;
        break;
      default:
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	{
!           fprintf (vect_dump, "unsupported defining stmt: ");
! 	  print_generic_expr (vect_dump, def_stmt, TDF_SLIM);
  	}
        internal_error ("unsupported defining stmt");
      }
  
!   /* Build a tree with vector elements. 
!      Create 'vec_inv = {inv,inv,..,inv}'  */
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "Create vector_inv.");
  
    for (i = nunits - 1; i >= 0; --i)
      {
*************** vect_finish_stmt_generation (tree stmt, 
*** 2455,2464 ****
  {
    bsi_insert_before (bsi, vec_stmt, BSI_SAME_STMT);
  
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "add new stmt: ");
!       print_generic_expr (dump_file, vec_stmt, TDF_SLIM);
      }
  
    /* Make sure bsi points to the stmt that is being vectorized.  */
--- 2512,2521 ----
  {
    bsi_insert_before (bsi, vec_stmt, BSI_SAME_STMT);
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "add new stmt: ");
!       print_generic_expr (vect_dump, vec_stmt, TDF_SLIM);
      }
  
    /* Make sure bsi points to the stmt that is being vectorized.  */
*************** vectorizable_assignment (tree stmt, bloc
*** 2504,2511 ****
    op = TREE_OPERAND (stmt, 1);
    if (!vect_is_simple_use (op, loop_vinfo, NULL))
      {
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "use not simple.");
        return false;
      }
  
--- 2561,2568 ----
    op = TREE_OPERAND (stmt, 1);
    if (!vect_is_simple_use (op, loop_vinfo, NULL))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "use not simple.");
        return false;
      }
  
*************** vectorizable_assignment (tree stmt, bloc
*** 2516,2523 ****
      }
  
    /** Trasform.  **/
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "transform assignment.");
  
    /* Handle def.  */
    vec_dest = vect_create_destination_var (scalar_dest, vectype);
--- 2573,2580 ----
      }
  
    /** Trasform.  **/
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "transform assignment.");
  
    /* Handle def.  */
    vec_dest = vect_create_destination_var (scalar_dest, vectype);
*************** vectorizable_operation (tree stmt, block
*** 2577,2584 ****
    op_type = TREE_CODE_LENGTH (code);
    if (op_type != unary_op && op_type != binary_op)
      {
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "num. args = %d (not unary/binary op).", op_type);
        return false;
      }
  
--- 2634,2641 ----
    op_type = TREE_CODE_LENGTH (code);
    if (op_type != unary_op && op_type != binary_op)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "num. args = %d (not unary/binary op).", op_type);
        return false;
      }
  
*************** vectorizable_operation (tree stmt, block
*** 2587,2594 ****
        op = TREE_OPERAND (operation, i);
        if (!vect_is_simple_use (op, loop_vinfo, NULL))
  	{
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "use not simple.");
  	  return false;
  	}	
      } 
--- 2644,2651 ----
        op = TREE_OPERAND (operation, i);
        if (!vect_is_simple_use (op, loop_vinfo, NULL))
  	{
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "use not simple.");
  	  return false;
  	}	
      } 
*************** vectorizable_operation (tree stmt, block
*** 2596,2610 ****
    /* Supportable by target?  */
    if (!optab)
      {
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "no optab.");
        return false;
      }
    vec_mode = TYPE_MODE (vectype);
    if (optab->handlers[(int) vec_mode].insn_code == CODE_FOR_nothing)
      {
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "op not supported by target.");
        return false;
      }
  
--- 2653,2667 ----
    /* Supportable by target?  */
    if (!optab)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "no optab.");
        return false;
      }
    vec_mode = TYPE_MODE (vectype);
    if (optab->handlers[(int) vec_mode].insn_code == CODE_FOR_nothing)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "op not supported by target.");
        return false;
      }
  
*************** vectorizable_operation (tree stmt, block
*** 2616,2623 ****
  
    /** Transform.  **/
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "transform binary/unary operation.");
  
    /* Handle def.  */
    scalar_dest = TREE_OPERAND (stmt, 0);
--- 2673,2680 ----
  
    /** Transform.  **/
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "transform binary/unary operation.");
  
    /* Handle def.  */
    scalar_dest = TREE_OPERAND (stmt, 0);
*************** vectorizable_store (tree stmt, block_stm
*** 2685,2692 ****
    op = TREE_OPERAND (stmt, 1);
    if (!vect_is_simple_use (op, loop_vinfo, NULL))
      {
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "use not simple.");
        return false;
      }
  
--- 2742,2749 ----
    op = TREE_OPERAND (stmt, 1);
    if (!vect_is_simple_use (op, loop_vinfo, NULL))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "use not simple.");
        return false;
      }
  
*************** vectorizable_store (tree stmt, block_stm
*** 2708,2715 ****
  
    /** Trasform.  **/
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "transform store");
  
    alignment_support_cheme = vect_supportable_dr_alignment (dr);
    gcc_assert (alignment_support_cheme);
--- 2765,2772 ----
  
    /** Trasform.  **/
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "transform store");
  
    alignment_support_cheme = vect_supportable_dr_alignment (dr);
    gcc_assert (alignment_support_cheme);
*************** vectorizable_load (tree stmt, block_stmt
*** 2783,2790 ****
      (e.g. - data copies).  */
    if (mov_optab->handlers[mode].insn_code == CODE_FOR_nothing)
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "Aligned load, but unsupported type.");
        return false;
      }
  
--- 2840,2847 ----
      (e.g. - data copies).  */
    if (mov_optab->handlers[mode].insn_code == CODE_FOR_nothing)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "Aligned load, but unsupported type.");
        return false;
      }
  
*************** vectorizable_load (tree stmt, block_stmt
*** 2796,2803 ****
  
    /** Trasform.  **/
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "transform load.");
  
    alignment_support_cheme = vect_supportable_dr_alignment (dr);
    gcc_assert (alignment_support_cheme);
--- 2853,2860 ----
  
    /** Trasform.  **/
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "transform load.");
  
    alignment_support_cheme = vect_supportable_dr_alignment (dr);
    gcc_assert (alignment_support_cheme);
*************** vect_transform_stmt (tree stmt, block_st
*** 3003,3010 ****
        is_store = true;
        break;
      default:
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "stmt not supported.");
        gcc_unreachable ();
      }
  
--- 3060,3067 ----
        is_store = true;
        break;
      default:
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "stmt not supported.");
        gcc_unreachable ();
      }
  
*************** vect_update_ivs_after_vectorizer (loop_v
*** 3176,3183 ****
        /* Skip virtual phi's.  */
        if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
  	{
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "virtual phi. skip.");
  	  continue;
  	}
  
--- 3233,3240 ----
        /* Skip virtual phi's.  */
        if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
  	{
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "virtual phi. skip.");
  	  continue;
  	}
  
*************** vect_do_peeling_for_loop_bound (loop_vec
*** 3240,3247 ****
    int loop_num;
  #endif
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_transtorm_for_unknown_loop_bound>>\n");
  
    /* Generate the following variables on the preheader of original loop:
  	 
--- 3297,3304 ----
    int loop_num;
  #endif
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_transtorm_for_unknown_loop_bound ==\n");
  
    /* Generate the following variables on the preheader of original loop:
  	 
*************** vect_update_inits_of_drs (loop_vec_info 
*** 3409,3416 ****
    varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo);
    varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo);
  
!   if (dump_file && (dump_flags & TDF_DETAILS))
!     fprintf (dump_file, "\n<<vect_update_inits_of_dr>>\n");
  
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
      {
--- 3466,3473 ----
    varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo);
    varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo);
  
!   if (vect_dump && (dump_flags & TDF_DETAILS))
!     fprintf (vect_dump, "\n== vect_update_inits_of_dr ==\n");
  
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
      {
*************** vect_do_peeling_for_alignment (loop_vec_
*** 3442,3452 ****
    tree n_iters;
    struct loop *new_loop;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_do_peeling_for_alignment>>\n");
  
    ni_name = vect_build_loop_niters (loop_vinfo);
!   niters_of_prolog_loop = vect_gen_niters_for_prolog_loop (loop_vinfo, ni_name);
    
    /* Peel the prolog loop and iterate it niters_of_prolog_loop.  */
    new_loop = 
--- 3499,3510 ----
    tree n_iters;
    struct loop *new_loop;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_do_peeling_for_alignment ==\n");
  
    ni_name = vect_build_loop_niters (loop_vinfo);
!   niters_of_prolog_loop = vect_gen_niters_for_prolog_loop (loop_vinfo, 
!                                                            ni_name);
    
    /* Peel the prolog loop and iterate it niters_of_prolog_loop.  */
    new_loop = 
*************** vect_transform_loop (loop_vec_info loop_
*** 3490,3497 ****
    tree ratio = NULL;
    int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vec_transform_loop>>\n");
  
    
    /* Peel the loop if there are data refs with unknown alignment.
--- 3548,3555 ----
    tree ratio = NULL;
    int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vec_transform_loop ==\n");
  
    
    /* Peel the loop if there are data refs with unknown alignment.
*************** vect_transform_loop (loop_vec_info loop_
*** 3539,3548 ****
  	  stmt_vec_info stmt_info;
  	  bool is_store;
  
! 	  if (vect_debug_details (UNKNOWN_LOC))
  	    {
! 	      fprintf (dump_file, "------>vectorizing statement: ");
! 	      print_generic_expr (dump_file, stmt, TDF_SLIM);
  	    }	
  	  stmt_info = vinfo_for_stmt (stmt);
  	  gcc_assert (stmt_info);
--- 3597,3606 ----
  	  stmt_vec_info stmt_info;
  	  bool is_store;
  
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	    {
! 	      fprintf (vect_dump, "------>vectorizing statement: ");
! 	      print_generic_expr (vect_dump, stmt, TDF_SLIM);
  	    }	
  	  stmt_info = vinfo_for_stmt (stmt);
  	  gcc_assert (stmt_info);
*************** vect_transform_loop (loop_vec_info loop_
*** 3559,3566 ****
  		 == vectorization_factor);
  #endif
  	  /* -------- vectorize statement ------------ */
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "transform statement.");
  
  	  is_store = vect_transform_stmt (stmt, &si);
  	  if (is_store)
--- 3617,3624 ----
  		 == vectorization_factor);
  #endif
  	  /* -------- vectorize statement ------------ */
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "transform statement.");
  
  	  is_store = vect_transform_stmt (stmt, &si);
  	  if (is_store)
*************** vect_transform_loop (loop_vec_info loop_
*** 3579,3588 ****
  
    slpeel_make_loop_iterate_ntimes (loop, ratio);
  
!   if (vect_debug_details (LOOP_LOC (loop_vinfo)))
!     fprintf (dump_file,"Success! loop vectorized.");
!   if (vect_debug_stats (LOOP_LOC (loop_vinfo)))
!     fprintf (dump_file, "LOOP VECTORIZED.");
  }
  
  
--- 3637,3644 ----
  
    slpeel_make_loop_iterate_ntimes (loop, ratio);
  
!   if (vect_print_dump_info (REPORT_VECTORIZED_LOOPS, LOOP_LOC (loop_vinfo)))
!     fprintf (vect_dump, "LOOP VECTORIZED.");
  }
  
  
*************** vect_is_simple_use (tree operand, loop_v
*** 3618,3625 ****
    def_stmt = SSA_NAME_DEF_STMT (operand);
    if (def_stmt == NULL_TREE )
      {
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "no def_stmt.");
        return false;
      }
  
--- 3674,3681 ----
    def_stmt = SSA_NAME_DEF_STMT (operand);
    if (def_stmt == NULL_TREE )
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "no def_stmt.");
        return false;
      }
  
*************** vect_is_simple_use (tree operand, loop_v
*** 3630,3639 ****
        tree arg = TREE_OPERAND (def_stmt, 0);
        if (TREE_CODE (arg) == INTEGER_CST || TREE_CODE (arg) == REAL_CST)
  	return true;
!       if (vect_debug_details (UNKNOWN_LOC))
  	{
! 	  fprintf (dump_file, "Unexpected empty stmt: ");
! 	  print_generic_expr (dump_file, def_stmt, TDF_SLIM);
  	}
        return false;  
      }
--- 3686,3695 ----
        tree arg = TREE_OPERAND (def_stmt, 0);
        if (TREE_CODE (arg) == INTEGER_CST || TREE_CODE (arg) == REAL_CST)
  	return true;
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	{
! 	  fprintf (vect_dump, "Unexpected empty stmt: ");
! 	  print_generic_expr (vect_dump, def_stmt, TDF_SLIM);
  	}
        return false;  
      }
*************** vect_is_simple_use (tree operand, loop_v
*** 3643,3650 ****
    bb = bb_for_stmt (def_stmt);
    if (TREE_CODE (def_stmt) == PHI_NODE && flow_bb_inside_loop_p (loop, bb))
      {
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "reduction/induction - unsupported.");
        return false; /* FORNOW: not supported yet.  */
      }
  
--- 3699,3706 ----
    bb = bb_for_stmt (def_stmt);
    if (TREE_CODE (def_stmt) == PHI_NODE && flow_bb_inside_loop_p (loop, bb))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "reduction/induction - unsupported.");
        return false; /* FORNOW: not supported yet.  */
      }
  
*************** vect_analyze_operations (loop_vec_info l
*** 3677,3684 ****
    bool ok;
    tree scalar_type;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_analyze_operations>>\n");
  
    for (i = 0; i < nbbs; i++)
      {
--- 3733,3740 ----
    bool ok;
    tree scalar_type;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_analyze_operations ==\n");
  
    for (i = 0; i < nbbs; i++)
      {
*************** vect_analyze_operations (loop_vec_info l
*** 3691,3700 ****
  	  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
  	  tree vectype;
  
! 	  if (vect_debug_details (UNKNOWN_LOC))
  	    {
! 	      fprintf (dump_file, "==> examining statement: ");
! 	      print_generic_expr (dump_file, stmt, TDF_SLIM);
  	    }
  
  	  gcc_assert (stmt_info);
--- 3747,3756 ----
  	  stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
  	  tree vectype;
  
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	    {
! 	      fprintf (vect_dump, "==> examining statement: ");
! 	      print_generic_expr (vect_dump, stmt, TDF_SLIM);
  	    }
  
  	  gcc_assert (stmt_info);
*************** vect_analyze_operations (loop_vec_info l
*** 3708,3725 ****
  
  	  if (!STMT_VINFO_RELEVANT_P (stmt_info))
  	    {
! 	      if (vect_debug_details (UNKNOWN_LOC))
! 	        fprintf (dump_file, "irrelevant.");
  	      continue;
  	    }
  
  	  if (VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))))
  	    {
! 	      if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!                   || vect_debug_details (LOOP_LOC (loop_vinfo)))
  		{
!                   fprintf (dump_file, "not vectorized: vector stmt in loop:");
! 		  print_generic_expr (dump_file, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
--- 3764,3781 ----
  
  	  if (!STMT_VINFO_RELEVANT_P (stmt_info))
  	    {
! 	      if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	        fprintf (vect_dump, "irrelevant.");
  	      continue;
  	    }
  
  	  if (VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))))
  	    {
! 	      if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                          LOOP_LOC (loop_vinfo))) 
  		{
!                   fprintf (vect_dump, "not vectorized: vector stmt in loop:");
! 		  print_generic_expr (vect_dump, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
*************** vect_analyze_operations (loop_vec_info l
*** 3731,3758 ****
  	  else
  	    scalar_type = TREE_TYPE (stmt);
  
! 	  if (vect_debug_details (UNKNOWN_LOC))
  	    {
! 	      fprintf (dump_file, "get vectype for scalar type:  ");
! 	      print_generic_expr (dump_file, scalar_type, TDF_SLIM);
  	    }
  
  	  vectype = get_vectype_for_scalar_type (scalar_type);
  	  if (!vectype)
  	    {
! 	      if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!                   || vect_debug_details (LOOP_LOC (loop_vinfo)))
  		{
!                   fprintf (dump_file, "not vectorized: unsupported data-type ");
! 		  print_generic_expr (dump_file, scalar_type, TDF_SLIM);
  		}
  	      return false;
  	    }
  
! 	  if (vect_debug_details (UNKNOWN_LOC))
  	    {
! 	      fprintf (dump_file, "vectype: ");
! 	      print_generic_expr (dump_file, vectype, TDF_SLIM);
  	    }
  	  STMT_VINFO_VECTYPE (stmt_info) = vectype;
  
--- 3787,3815 ----
  	  else
  	    scalar_type = TREE_TYPE (stmt);
  
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	    {
! 	      fprintf (vect_dump, "get vectype for scalar type:  ");
! 	      print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
  	    }
  
  	  vectype = get_vectype_for_scalar_type (scalar_type);
  	  if (!vectype)
  	    {
! 	      if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                          LOOP_LOC (loop_vinfo))) 
  		{
!                   fprintf (vect_dump, 
!                            "not vectorized: unsupported data-type ");
! 		  print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
  		}
  	      return false;
  	    }
  
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	    {
! 	      fprintf (vect_dump, "vectype: ");
! 	      print_generic_expr (vect_dump, vectype, TDF_SLIM);
  	    }
  	  STMT_VINFO_VECTYPE (stmt_info) = vectype;
  
*************** vect_analyze_operations (loop_vec_info l
*** 3763,3780 ****
  
  	  if (!ok)
  	    {
! 	      if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!                   || vect_debug_details (LOOP_LOC (loop_vinfo)))
  		{
!                   fprintf (dump_file, "not vectorized: stmt not supported: ");
! 		  print_generic_expr (dump_file, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
  
  	  nunits = GET_MODE_NUNITS (TYPE_MODE (vectype));
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "nunits = %d", nunits);
  
  	  if (vectorization_factor)
  	    {
--- 3820,3837 ----
  
  	  if (!ok)
  	    {
! 	      if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                          LOOP_LOC (loop_vinfo))) 
  		{
!                   fprintf (vect_dump, "not vectorized: stmt not supported: ");
! 		  print_generic_expr (vect_dump, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
  
  	  nunits = GET_MODE_NUNITS (TYPE_MODE (vectype));
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "nunits = %d", nunits);
  
  	  if (vectorization_factor)
  	    {
*************** vect_analyze_operations (loop_vec_info l
*** 3782,3790 ****
  	         This restriction will be relaxed in the future.  */
  	      if (nunits != vectorization_factor)
  		{
! 	          if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!                       || vect_debug_details (LOOP_LOC (loop_vinfo)))
! 		    fprintf (dump_file, "not vectorized: mixed data-types");
  		  return false;
  		}
  	    }
--- 3839,3847 ----
  	         This restriction will be relaxed in the future.  */
  	      if (nunits != vectorization_factor)
  		{
! 	          if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
!                                              LOOP_LOC (loop_vinfo))) 
! 		    fprintf (vect_dump, "not vectorized: mixed data-types");
  		  return false;
  		}
  	    }
*************** vect_analyze_operations (loop_vec_info l
*** 3802,3847 ****
  
    if (vectorization_factor <= 1)
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo)))
!         fprintf (dump_file, "not vectorized: unsupported data-type");
        return false;
      }
    LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
  
    if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo) 
!       && vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file,
          "vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC,
          vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo));
  
    if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
        && LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor)
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "not vectorized: iteration count too small.");
        return false;
      }
  
    if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
        || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0)
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo)))
!         fprintf (dump_file, "epilog loop required.");
        if (!vect_can_advance_ivs_p (loop_vinfo))
          {
!           if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!               || vect_debug_details (LOOP_LOC (loop_vinfo)))
!             fprintf (dump_file, "not vectorized: can't create epilog loop 1.");
            return false;
          }
        if (!slpeel_can_duplicate_loop_p (loop, loop->exit_edges[0]))
          {
!           if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!               || vect_debug_details (LOOP_LOC (loop_vinfo)))
!             fprintf (dump_file, "not vectorized: can't create epilog loop 2.");
            return false;
          }
      }
--- 3859,3905 ----
  
    if (vectorization_factor <= 1)
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
!         fprintf (vect_dump, "not vectorized: unsupported data-type");
        return false;
      }
    LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
  
    if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo) 
!       && vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump,
          "vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC,
          vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo));
  
    if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
        && LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor)
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
!                                  LOOP_LOC (loop_vinfo))) 
! 	fprintf (vect_dump, "not vectorized: iteration count too small.");
        return false;
      }
  
    if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
        || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo))) 
!         fprintf (vect_dump, "epilog loop required.");
        if (!vect_can_advance_ivs_p (loop_vinfo))
          {
!           if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                      LOOP_LOC (loop_vinfo))) 
!             fprintf (vect_dump, 
!                      "not vectorized: can't create epilog loop 1.");
            return false;
          }
        if (!slpeel_can_duplicate_loop_p (loop, loop->exit_edges[0]))
          {
!           if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                      LOOP_LOC (loop_vinfo))) 
!             fprintf (vect_dump, 
!                      "not vectorized: can't create epilog loop 2.");
            return false;
          }
      }
*************** vect_is_simple_iv_evolution (unsigned lo
*** 3920,3933 ****
      return false;
    
    step_expr = evolution_part;
!   init_expr = unshare_expr (initial_condition_in_loop_num (access_fn, loop_nb));
  
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "step: ");
!       print_generic_expr (dump_file, step_expr, TDF_SLIM);
!       fprintf (dump_file, ",  init: ");
!       print_generic_expr (dump_file, init_expr, TDF_SLIM);
      }
  
    *init = init_expr;
--- 3978,3992 ----
      return false;
    
    step_expr = evolution_part;
!   init_expr = unshare_expr (initial_condition_in_loop_num (access_fn, 
!                                                            loop_nb));
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "step: ");
!       print_generic_expr (vect_dump, step_expr, TDF_SLIM);
!       fprintf (vect_dump, ",  init: ");
!       print_generic_expr (vect_dump, init_expr, TDF_SLIM);
      }
  
    *init = init_expr;
*************** vect_is_simple_iv_evolution (unsigned lo
*** 3935,3950 ****
  
    if (TREE_CODE (step_expr) != INTEGER_CST)
      {
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "step unknown.");
        return false;
      }
  
    if (strict)
      if (!integer_onep (step_expr))
        {
!         if (vect_debug_details (UNKNOWN_LOC))
! 	  print_generic_expr (dump_file, step_expr, TDF_SLIM);
          return false;
        }
  
--- 3994,4009 ----
  
    if (TREE_CODE (step_expr) != INTEGER_CST)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "step unknown.");
        return false;
      }
  
    if (strict)
      if (!integer_onep (step_expr))
        {
!         if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	  print_generic_expr (vect_dump, step_expr, TDF_SLIM);
          return false;
        }
  
*************** vect_analyze_scalar_cycles (loop_vec_inf
*** 3996,4012 ****
    basic_block bb = loop->header;
    tree dummy;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_analyze_scalar_cycles>>\n");
  
    for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
      {
        tree access_fn = NULL;
  
!       if (vect_debug_details (UNKNOWN_LOC))
  	{
!           fprintf (dump_file, "Analyze phi: ");
!           print_generic_expr (dump_file, phi, TDF_SLIM);
  	}
  
        /* Skip virtual phi's. The data dependences that are associated with
--- 4055,4071 ----
    basic_block bb = loop->header;
    tree dummy;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_analyze_scalar_cycles ==\n");
  
    for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
      {
        tree access_fn = NULL;
  
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	{
!           fprintf (vect_dump, "Analyze phi: ");
!           print_generic_expr (vect_dump, phi, TDF_SLIM);
  	}
  
        /* Skip virtual phi's. The data dependences that are associated with
*************** vect_analyze_scalar_cycles (loop_vec_inf
*** 4014,4021 ****
  
        if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
  	{
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "virtual phi. skip.");
  	  continue;
  	}
  
--- 4073,4080 ----
  
        if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
  	{
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "virtual phi. skip.");
  	  continue;
  	}
  
*************** vect_analyze_scalar_cycles (loop_vec_inf
*** 4036,4059 ****
  
        if (!access_fn)
  	{
! 	  if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!               || vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	    fprintf (dump_file, "not vectorized: unsupported scalar cycle.");
  	  return false;
  	}
  
!       if (vect_debug_details (UNKNOWN_LOC))
          {
!            fprintf (dump_file, "Access function of PHI: ");
!            print_generic_expr (dump_file, access_fn, TDF_SLIM);
          }
  
        if (!vect_is_simple_iv_evolution (loop->num, access_fn, &dummy, 
  					&dummy, false))
  	{
! 	  if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!               || vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	    fprintf (dump_file, "not vectorized: unsupported scalar cycle.");
  	  return false;
  	}
      }
--- 4095,4118 ----
  
        if (!access_fn)
  	{
! 	  if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                      LOOP_LOC (loop_vinfo))) 
! 	    fprintf (vect_dump, "not vectorized: unsupported scalar cycle.");
  	  return false;
  	}
  
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
          {
!            fprintf (vect_dump, "Access function of PHI: ");
!            print_generic_expr (vect_dump, access_fn, TDF_SLIM);
          }
  
        if (!vect_is_simple_iv_evolution (loop->num, access_fn, &dummy, 
  					&dummy, false))
  	{
! 	  if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                      LOOP_LOC (loop_vinfo))) 
! 	    fprintf (vect_dump, "not vectorized: unsupported scalar cycle.");
  	  return false;
  	}
      }
*************** vect_analyze_data_ref_dependence (struct
*** 4077,4090 ****
    
    if (!array_base_name_differ_p (dra, drb, &differ_p))
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo)))   
          {
!           fprintf (dump_file,
                  "not vectorized: can't determine dependence between: ");
!           print_generic_expr (dump_file, DR_REF (dra), TDF_SLIM);
!           fprintf (dump_file, " and ");
!           print_generic_expr (dump_file, DR_REF (drb), TDF_SLIM);
          }
        return true;
      }
--- 4136,4149 ----
    
    if (!array_base_name_differ_p (dra, drb, &differ_p))
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
          {
!           fprintf (vect_dump,
                  "not vectorized: can't determine dependence between: ");
!           print_generic_expr (vect_dump, DR_REF (dra), TDF_SLIM);
!           fprintf (vect_dump, " and ");
!           print_generic_expr (vect_dump, DR_REF (drb), TDF_SLIM);
          }
        return true;
      }
*************** vect_analyze_data_ref_dependence (struct
*** 4098,4111 ****
    if (DDR_ARE_DEPENDENT (ddr) == chrec_known)
      return false;
    
!   if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!       || vect_debug_details (LOOP_LOC (loop_vinfo)))
      {
!       fprintf (dump_file,
  	"not vectorized: possible dependence between data-refs ");
!       print_generic_expr (dump_file, DR_REF (dra), TDF_SLIM);
!       fprintf (dump_file, " and ");
!       print_generic_expr (dump_file, DR_REF (drb), TDF_SLIM);
      }
  
    return true;
--- 4157,4170 ----
    if (DDR_ARE_DEPENDENT (ddr) == chrec_known)
      return false;
    
!   if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                              LOOP_LOC (loop_vinfo))) 
      {
!       fprintf (vect_dump,
  	"not vectorized: possible dependence between data-refs ");
!       print_generic_expr (vect_dump, DR_REF (dra), TDF_SLIM);
!       fprintf (vect_dump, " and ");
!       print_generic_expr (vect_dump, DR_REF (drb), TDF_SLIM);
      }
  
    return true;
*************** vect_analyze_data_ref_dependences (loop_
*** 4129,4139 ****
  
    /* Examine store-store (output) dependences.  */
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_analyze_dependences>>\n");
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "compare all store-store pairs.");
  
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_refs); i++)
      {
--- 4188,4198 ----
  
    /* Examine store-store (output) dependences.  */
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_analyze_dependences ==\n");
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "compare all store-store pairs.");
  
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_refs); i++)
      {
*************** vect_analyze_data_ref_dependences (loop_
*** 4150,4157 ****
  
    /* Examine load-store (true/anti) dependences.  */
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "compare all load-store pairs.");
  
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_read_refs); i++)
      {
--- 4209,4216 ----
  
    /* Examine load-store (true/anti) dependences.  */
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "compare all load-store pairs.");
  
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_read_refs); i++)
      {
*************** vect_compute_data_ref_alignment (struct 
*** 4192,4199 ****
    bool base_aligned_p;
    tree misalign;
     
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "vect_compute_data_ref_alignment:");
  
    /* Initialize misalignment to unknown.  */
    DR_MISALIGNMENT (dr) = -1;
--- 4251,4258 ----
    bool base_aligned_p;
    tree misalign;
     
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "vect_compute_data_ref_alignment:");
  
    /* Initialize misalignment to unknown.  */
    DR_MISALIGNMENT (dr) = -1;
*************** vect_compute_data_ref_alignment (struct 
*** 4205,4214 ****
  
    if (!misalign)
      {
!       if (vect_debug_details (UNKNOWN_LOC)) 
  	{
! 	  fprintf (dump_file, "Unknown alignment for access: ");
! 	  print_generic_expr (dump_file, base, TDF_SLIM);
  	}
        return true;
      }
--- 4264,4273 ----
  
    if (!misalign)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC)) 
  	{
! 	  fprintf (vect_dump, "Unknown alignment for access: ");
! 	  print_generic_expr (vect_dump, base, TDF_SLIM);
  	}
        return true;
      }
*************** vect_compute_data_ref_alignment (struct 
*** 4217,4226 ****
      {
        if (!vect_can_force_dr_alignment_p (base, TYPE_ALIGN (vectype)))
  	{
! 	  if (vect_debug_details (UNKNOWN_LOC))
  	    {
! 	      fprintf (dump_file, "can't force alignment of ref: ");
! 	      print_generic_expr (dump_file, ref, TDF_SLIM);
  	    }
  	  return true;
  	}
--- 4276,4285 ----
      {
        if (!vect_can_force_dr_alignment_p (base, TYPE_ALIGN (vectype)))
  	{
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	    {
! 	      fprintf (vect_dump, "can't force alignment of ref: ");
! 	      print_generic_expr (vect_dump, ref, TDF_SLIM);
  	    }
  	  return true;
  	}
*************** vect_compute_data_ref_alignment (struct 
*** 4228,4235 ****
        /* Force the alignment of the decl.
  	 NOTE: This is the only change to the code we make during
  	 the analysis phase, before deciding to vectorize the loop.  */
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "force alignment");
        DECL_ALIGN (base) = TYPE_ALIGN (vectype);
        DECL_USER_ALIGN (base) = 1;
      }
--- 4287,4294 ----
        /* Force the alignment of the decl.
  	 NOTE: This is the only change to the code we make during
  	 the analysis phase, before deciding to vectorize the loop.  */
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "force alignment");
        DECL_ALIGN (base) = TYPE_ALIGN (vectype);
        DECL_USER_ALIGN (base) = 1;
      }
*************** vect_compute_data_ref_alignment (struct 
*** 4247,4261 ****
    if (tree_int_cst_sgn (misalign) < 0)
      {
        /* Negative misalignment value.  */
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "unexpected misalign value");
        return false;
      }
  
    DR_MISALIGNMENT (dr) = tree_low_cst (misalign, 1);
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "misalign = %d", DR_MISALIGNMENT (dr));
  
    return true;
  }
--- 4306,4320 ----
    if (tree_int_cst_sgn (misalign) < 0)
      {
        /* Negative misalignment value.  */
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "unexpected misalign value");
        return false;
      }
  
    DR_MISALIGNMENT (dr) = tree_low_cst (misalign, 1);
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "misalign = %d bytes", DR_MISALIGNMENT (dr));
  
    return true;
  }
*************** vect_enhance_data_refs_alignment (loop_v
*** 4424,4436 ****
  
    if (!LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "Peeling for alignment will not be applied.");
        return;
      }
    else
!     if (vect_debug_details (LOOP_LOC (loop_vinfo)))
!       fprintf (dump_file, "Peeling for alignment will be applied.");
  
  
    /* (1.2) Update the alignment info according to the peeling factor.
--- 4483,4495 ----
  
    if (!LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "Peeling for alignment will not be applied.");
        return;
      }
    else
!     if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
!       fprintf (vect_dump, "Peeling for alignment will be applied.");
  
  
    /* (1.2) Update the alignment info according to the peeling factor.
*************** vect_enhance_data_refs_alignment (loop_v
*** 4454,4462 ****
        if (dr == LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
  	{
  	  DR_MISALIGNMENT (dr) = 0;
! 	  if (vect_debug_details (LOOP_LOC (loop_vinfo)) 
! 	      || vect_debug_stats (LOOP_LOC (loop_vinfo)))
! 	    fprintf (dump_file, "Alignment of access forced using peeling.");
  	}
        else
  	DR_MISALIGNMENT (dr) = -1;
--- 4513,4520 ----
        if (dr == LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
  	{
  	  DR_MISALIGNMENT (dr) = 0;
! 	  if (vect_print_dump_info (REPORT_ALIGNMENT, LOOP_LOC (loop_vinfo))) 
! 	    fprintf (vect_dump, "Alignment of access forced using peeling.");
  	}
        else
  	DR_MISALIGNMENT (dr) = -1;
*************** vect_enhance_data_refs_alignment (loop_v
*** 4467,4475 ****
        if (dr == LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
  	{
  	  DR_MISALIGNMENT (dr) = 0;
! 	  if (vect_debug_details (LOOP_LOC (loop_vinfo))
! 	      || vect_debug_stats (LOOP_LOC (loop_vinfo)))
! 	    fprintf (dump_file, "Alignment of access forced using peeling.");
  	}
        else
  	DR_MISALIGNMENT (dr) = -1;
--- 4525,4532 ----
        if (dr == LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
  	{
  	  DR_MISALIGNMENT (dr) = 0;
! 	  if (vect_print_dump_info (REPORT_ALIGNMENT, LOOP_LOC (loop_vinfo)))
! 	    fprintf (vect_dump, "Alignment of access forced using peeling.");
  	}
        else
  	DR_MISALIGNMENT (dr) = -1;
*************** vect_analyze_data_refs_alignment (loop_v
*** 4492,4499 ****
    enum dr_alignment_support supportable_dr_alignment;
    unsigned int i;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_analyze_data_refs_alignment>>\n");
  
  
    /* This pass may take place at function granularity instead of at loop
--- 4549,4556 ----
    enum dr_alignment_support supportable_dr_alignment;
    unsigned int i;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_analyze_data_refs_alignment ==\n");
  
  
    /* This pass may take place at function granularity instead of at loop
*************** vect_analyze_data_refs_alignment (loop_v
*** 4501,4509 ****
  
    if (!vect_compute_data_refs_alignment (loop_vinfo))
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_stats (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, 
  		 "not vectorized: can't calculate alignment for data ref.");
        return false;
      }
--- 4558,4566 ----
  
    if (!vect_compute_data_refs_alignment (loop_vinfo))
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
! 	fprintf (vect_dump, 
  		 "not vectorized: can't calculate alignment for data ref.");
        return false;
      }
*************** vect_analyze_data_refs_alignment (loop_v
*** 4524,4538 ****
        supportable_dr_alignment = vect_supportable_dr_alignment (dr);
        if (!supportable_dr_alignment)
  	{
! 	  if (vect_debug_details (LOOP_LOC (loop_vinfo)) 
!               || vect_debug_stats (LOOP_LOC (loop_vinfo)))
! 	    fprintf (dump_file, "not vectorized: unsupported unaligned load.");
  	  return false;
  	}
        if (supportable_dr_alignment != dr_aligned 
! 	  && (vect_debug_details (LOOP_LOC (loop_vinfo)) 
! 	      || vect_debug_stats (LOOP_LOC (loop_vinfo))))
! 	fprintf (dump_file, "Vectorizing an unaligned access.");
      }
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
      {
--- 4581,4594 ----
        supportable_dr_alignment = vect_supportable_dr_alignment (dr);
        if (!supportable_dr_alignment)
  	{
! 	  if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                      LOOP_LOC (loop_vinfo))) 
! 	    fprintf (vect_dump, "not vectorized: unsupported unaligned load.");
  	  return false;
  	}
        if (supportable_dr_alignment != dr_aligned 
! 	  && (vect_print_dump_info (REPORT_ALIGNMENT, LOOP_LOC (loop_vinfo)))) 
! 	fprintf (vect_dump, "Vectorizing an unaligned access.");
      }
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
      {
*************** vect_analyze_data_refs_alignment (loop_v
*** 4540,4554 ****
        supportable_dr_alignment = vect_supportable_dr_alignment (dr);
        if (!supportable_dr_alignment)
  	{
! 	  if (vect_debug_details (LOOP_LOC (loop_vinfo)) 
!               || vect_debug_stats (LOOP_LOC (loop_vinfo)))
! 	    fprintf (dump_file, "not vectorized: unsupported unaligned store.");
  	  return false;
  	}
        if (supportable_dr_alignment != dr_aligned 
! 	  && (vect_debug_details (LOOP_LOC (loop_vinfo)) 
! 	      || vect_debug_stats (LOOP_LOC (loop_vinfo))))
! 	fprintf (dump_file, "Vectorizing an unaligned access.");
      }
  
    return true;
--- 4596,4609 ----
        supportable_dr_alignment = vect_supportable_dr_alignment (dr);
        if (!supportable_dr_alignment)
  	{
! 	  if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                      LOOP_LOC (loop_vinfo))) 
! 	    fprintf (vect_dump, "not vectorized: unsupported unaligned store.");
  	  return false;
  	}
        if (supportable_dr_alignment != dr_aligned 
! 	  && (vect_print_dump_info (REPORT_ALIGNMENT, LOOP_LOC (loop_vinfo)))) 
! 	fprintf (vect_dump, "Vectorizing an unaligned access.");
      }
  
    return true;
*************** vect_analyze_data_ref_access (struct dat
*** 4570,4577 ****
  
    if (!step || tree_int_cst_compare (step, TYPE_SIZE_UNIT (scalar_type)))
      {
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "not consecutive access");
        return false;
      }
    return true;
--- 4625,4632 ----
  
    if (!step || tree_int_cst_compare (step, TYPE_SIZE_UNIT (scalar_type)))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "not consecutive access");
        return false;
      }
    return true;
*************** vect_analyze_data_ref_accesses (loop_vec
*** 4594,4601 ****
    varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo);
    varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo);
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_analyze_data_ref_accesses>>\n");
  
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
      {
--- 4649,4656 ----
    varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo);
    varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo);
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_analyze_data_ref_accesses ==\n");
  
    for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
      {
*************** vect_analyze_data_ref_accesses (loop_vec
*** 4603,4611 ****
        bool ok = vect_analyze_data_ref_access (dr);
        if (!ok)
  	{
! 	  if (vect_debug_stats (LOOP_LOC (loop_vinfo))
! 	      || vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	    fprintf (dump_file, "not vectorized: complicated access pattern.");
  	  return false;
  	}
      }
--- 4658,4666 ----
        bool ok = vect_analyze_data_ref_access (dr);
        if (!ok)
  	{
! 	  if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                       LOOP_LOC (loop_vinfo)))
! 	    fprintf (vect_dump, "not vectorized: complicated access pattern.");
  	  return false;
  	}
      }
*************** vect_analyze_data_ref_accesses (loop_vec
*** 4616,4624 ****
        bool ok = vect_analyze_data_ref_access (dr);
        if (!ok)
  	{
! 	  if (vect_debug_stats (LOOP_LOC (loop_vinfo))
! 	      || vect_debug_details (LOOP_LOC (loop_vinfo))) 
! 	    fprintf (dump_file, "not vectorized: complicated access pattern.");
  	  return false;
  	}
      }
--- 4671,4679 ----
        bool ok = vect_analyze_data_ref_access (dr);
        if (!ok)
  	{
! 	  if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                      LOOP_LOC (loop_vinfo)))
! 	    fprintf (vect_dump, "not vectorized: complicated access pattern.");
  	  return false;
  	}
      }
*************** vect_analyze_pointer_ref_access (tree me
*** 4651,4673 ****
  
    if (!access_fn)
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo)))
!         fprintf (dump_file, "not vectorized: complicated pointer access.");	
        return NULL;
      }
  
!   if (vect_debug_details (UNKNOWN_LOC))
      {
!       fprintf (dump_file, "Access function of ptr: ");
!       print_generic_expr (dump_file, access_fn, TDF_SLIM);
      }
  
    if (!vect_is_simple_iv_evolution (loopnum, access_fn, &init, &step, false))
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo))) 
! 	fprintf (dump_file, "not vectorized: pointer access is not simple.");	
        return NULL;
      }
  		
--- 4706,4728 ----
  
    if (!access_fn)
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
!         fprintf (vect_dump, "not vectorized: complicated pointer access.");	
        return NULL;
      }
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
      {
!       fprintf (vect_dump, "Access function of ptr: ");
!       print_generic_expr (vect_dump, access_fn, TDF_SLIM);
      }
  
    if (!vect_is_simple_iv_evolution (loopnum, access_fn, &init, &step, false))
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
! 	fprintf (vect_dump, "not vectorized: pointer access is not simple.");	
        return NULL;
      }
  		
*************** vect_analyze_pointer_ref_access (tree me
*** 4675,4692 ****
  
    if (!expr_invariant_in_loop_p (loop, init))
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
! 	  || vect_debug_details (LOOP_LOC (loop_vinfo))) 
! 	fprintf (dump_file, 
  		 "not vectorized: initial condition is not loop invariant.");	
        return NULL;
      }
  
    if (TREE_CODE (step) != INTEGER_CST)
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo))) 
! 	fprintf (dump_file, 
  		"not vectorized: non constant step for pointer access.");	
        return NULL;
      }
--- 4730,4747 ----
  
    if (!expr_invariant_in_loop_p (loop, init))
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
! 	fprintf (vect_dump, 
  		 "not vectorized: initial condition is not loop invariant.");	
        return NULL;
      }
  
    if (TREE_CODE (step) != INTEGER_CST)
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
! 	fprintf (vect_dump, 
  		"not vectorized: non constant step for pointer access.");	
        return NULL;
      }
*************** vect_analyze_pointer_ref_access (tree me
*** 4694,4711 ****
    reftype = TREE_TYPE (TREE_OPERAND (memref, 0));
    if (TREE_CODE (reftype) != POINTER_TYPE) 
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "not vectorized: unexpected pointer access form.");	
        return NULL;
      }
  
    reftype = TREE_TYPE (init);
    if (TREE_CODE (reftype) != POINTER_TYPE) 
      {
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo))) 
! 	fprintf (dump_file, "not vectorized: unexpected pointer access form.");
        return NULL;
      }
  
--- 4749,4766 ----
    reftype = TREE_TYPE (TREE_OPERAND (memref, 0));
    if (TREE_CODE (reftype) != POINTER_TYPE) 
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
! 	fprintf (vect_dump, "not vectorized: unexpected pointer access form.");	
        return NULL;
      }
  
    reftype = TREE_TYPE (init);
    if (TREE_CODE (reftype) != POINTER_TYPE) 
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
! 	fprintf (vect_dump, "not vectorized: unexpected pointer access form.");
        return NULL;
      }
  
*************** vect_analyze_pointer_ref_access (tree me
*** 4713,4721 ****
    if (tree_int_cst_compare (TYPE_SIZE_UNIT (innertype), step))
      {
        /* FORNOW: support only consecutive access */
!       if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!           || vect_debug_details (LOOP_LOC (loop_vinfo))) 
! 	fprintf (dump_file, "not vectorized: non consecutive access.");	
        return NULL;
      }
  
--- 4768,4776 ----
    if (tree_int_cst_compare (TYPE_SIZE_UNIT (innertype), step))
      {
        /* FORNOW: support only consecutive access */
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                  LOOP_LOC (loop_vinfo))) 
! 	fprintf (vect_dump, "not vectorized: non consecutive access.");	
        return NULL;
      }
  
*************** vect_analyze_pointer_ref_access (tree me
*** 4730,4739 ****
  
    indx_access_fn = 
  	build_polynomial_chrec (loopnum, integer_zero_node, integer_one_node);
!   if (vect_debug_details (UNKNOWN_LOC)) 
      {
!       fprintf (dump_file, "Access function of ptr indx: ");
!       print_generic_expr (dump_file, indx_access_fn, TDF_SLIM);
      }
    dr = init_data_ref (stmt, memref, init, indx_access_fn, is_read);
    return dr;
--- 4785,4794 ----
  
    indx_access_fn = 
  	build_polynomial_chrec (loopnum, integer_zero_node, integer_one_node);
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC)) 
      {
!       fprintf (vect_dump, "Access function of ptr indx: ");
!       print_generic_expr (vect_dump, indx_access_fn, TDF_SLIM);
      }
    dr = init_data_ref (stmt, memref, init, indx_access_fn, is_read);
    return dr;
*************** vect_get_memtag_and_dr (tree memref, tre
*** 4804,4811 ****
  	    }
  	  if (!tag)
  	    {
! 	      if (vect_debug_details (UNKNOWN_LOC))
! 		fprintf (dump_file, "not vectorized: no memtag for ref.");
  	      return NULL_TREE;
  	    }
  	  return tag;
--- 4859,4867 ----
  	    }
  	  if (!tag)
  	    {
! 	      if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                          UNKNOWN_LOC))
! 		fprintf (vect_dump, "not vectorized: no memtag for ref.");
  	      return NULL_TREE;
  	    }
  	  return tag;
*************** vect_analyze_data_refs (loop_vec_info lo
*** 4962,4969 ****
    int j;
    struct data_reference *dr;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_analyze_data_refs>>\n");
  
    for (j = 0; j < nbbs; j++)
      {
--- 5018,5025 ----
    int j;
    struct data_reference *dr;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_analyze_data_refs ==\n");
  
    for (j = 0; j < nbbs; j++)
      {
*************** vect_analyze_data_refs (loop_vec_info lo
*** 4994,5013 ****
  
  	  if (nvuses && (nv_may_defs || nv_must_defs))
  	    {
! 	      if (vect_debug_details (UNKNOWN_LOC))
  		{
! 		  fprintf (dump_file, "unexpected vdefs and vuses in stmt: ");
! 		  print_generic_expr (dump_file, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
  
  	  if (TREE_CODE (stmt) != MODIFY_EXPR)
  	    {
! 	      if (vect_debug_details (UNKNOWN_LOC))
  		{
! 		  fprintf (dump_file, "unexpected vops in stmt: ");
! 		  print_generic_expr (dump_file, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
--- 5050,5069 ----
  
  	  if (nvuses && (nv_may_defs || nv_must_defs))
  	    {
! 	      if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  		{
! 		  fprintf (vect_dump, "unexpected vdefs and vuses in stmt: ");
! 		  print_generic_expr (vect_dump, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
  
  	  if (TREE_CODE (stmt) != MODIFY_EXPR)
  	    {
! 	      if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  		{
! 		  fprintf (vect_dump, "unexpected vops in stmt: ");
! 		  print_generic_expr (vect_dump, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
*************** vect_analyze_data_refs (loop_vec_info lo
*** 5029,5040 ****
  	  vectype = get_vectype_for_scalar_type (scalar_type);
  	  if (!vectype)
  	    {
! 	      if (vect_debug_details (UNKNOWN_LOC))
  		{
! 		  fprintf (dump_file, "no vectype for stmt: ");
! 		  print_generic_expr (dump_file, stmt, TDF_SLIM);
! 		  fprintf (dump_file, " scalar_type: ");
! 		  print_generic_expr (dump_file, scalar_type, TDF_DETAILS);
  		}
  	      /* It is not possible to vectorize this data reference.  */
  	      return false;
--- 5085,5096 ----
  	  vectype = get_vectype_for_scalar_type (scalar_type);
  	  if (!vectype)
  	    {
! 	      if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  		{
! 		  fprintf (vect_dump, "no vectype for stmt: ");
! 		  print_generic_expr (vect_dump, stmt, TDF_SLIM);
! 		  fprintf (vect_dump, " scalar_type: ");
! 		  print_generic_expr (vect_dump, scalar_type, TDF_DETAILS);
  		}
  	      /* It is not possible to vectorize this data reference.  */
  	      return false;
*************** vect_analyze_data_refs (loop_vec_info lo
*** 5046,5056 ****
  					  vectype, &dr);
  	  if (!symbl)
  	    {
! 	      if (vect_debug_stats (LOOP_LOC (loop_vinfo)) 
!                   || vect_debug_details (LOOP_LOC (loop_vinfo)))
  		{
! 		  fprintf (dump_file, "not vectorized: unhandled data ref: "); 
! 		  print_generic_expr (dump_file, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
--- 5102,5112 ----
  					  vectype, &dr);
  	  if (!symbl)
  	    {
! 	      if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                          LOOP_LOC (loop_vinfo))) 
  		{
! 		  fprintf (vect_dump, "not vectorized: unhandled data ref: "); 
! 		  print_generic_expr (vect_dump, stmt, TDF_SLIM);
  		}
  	      return false;
  	    }
*************** vect_mark_relevant (varray_type *worklis
*** 5076,5083 ****
  {
    stmt_vec_info stmt_info;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "mark relevant.");
  
    if (TREE_CODE (stmt) == PHI_NODE)
      {
--- 5132,5139 ----
  {
    stmt_vec_info stmt_info;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "mark relevant.");
  
    if (TREE_CODE (stmt) == PHI_NODE)
      {
*************** vect_mark_relevant (varray_type *worklis
*** 5089,5106 ****
  
    if (!stmt_info)
      {
!       if (vect_debug_details (UNKNOWN_LOC))
  	{
! 	  fprintf (dump_file, "mark relevant: no stmt info!!.");
! 	  print_generic_expr (dump_file, stmt, TDF_SLIM);
  	}
        return;
      }
  
    if (STMT_VINFO_RELEVANT_P (stmt_info))
      {
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "already marked relevant.");
        return;
      }
  
--- 5145,5162 ----
  
    if (!stmt_info)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	{
! 	  fprintf (vect_dump, "mark relevant: no stmt info!!.");
! 	  print_generic_expr (vect_dump, stmt, TDF_SLIM);
  	}
        return;
      }
  
    if (STMT_VINFO_RELEVANT_P (stmt_info))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "already marked relevant.");
        return;
      }
  
*************** vect_stmt_relevant_p (tree stmt, loop_ve
*** 5140,5147 ****
    v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
    if (v_may_defs || v_must_defs)
      {
!       if (vect_debug_details (UNKNOWN_LOC))
!         fprintf (dump_file, "vec_stmt_relevant_p: stmt has vdefs.");
        return true;
      }
  
--- 5196,5203 ----
    v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
    if (v_may_defs || v_must_defs)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!         fprintf (vect_dump, "vec_stmt_relevant_p: stmt has vdefs.");
        return true;
      }
  
*************** vect_stmt_relevant_p (tree stmt, loop_ve
*** 5154,5161 ****
        basic_block bb = bb_for_stmt (use);
        if (!flow_bb_inside_loop_p (loop, bb))
  	{
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "vec_stmt_relevant_p: used out of loop.");
  	  return true;
  	}
      }
--- 5210,5217 ----
        basic_block bb = bb_for_stmt (use);
        if (!flow_bb_inside_loop_p (loop, bb))
  	{
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "vec_stmt_relevant_p: used out of loop.");
  	  return true;
  	}
      }
*************** vect_mark_stmts_to_be_vectorized (loop_v
*** 5195,5202 ****
    use_optype use_ops;
    stmt_vec_info stmt_info;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<vect_mark_stmts_to_be_vectorized>>\n");
  
    VARRAY_TREE_INIT (worklist, 64, "work list");
  
--- 5251,5258 ----
    use_optype use_ops;
    stmt_vec_info stmt_info;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== vect_mark_stmts_to_be_vectorized ==\n");
  
    VARRAY_TREE_INIT (worklist, 64, "work list");
  
*************** vect_mark_stmts_to_be_vectorized (loop_v
*** 5209,5218 ****
  	{
  	  stmt = bsi_stmt (si);
  
! 	  if (vect_debug_details (UNKNOWN_LOC))
  	    {
! 	      fprintf (dump_file, "init: stmt relevant? ");
! 	      print_generic_expr (dump_file, stmt, TDF_SLIM);
  	    } 
  
  	  stmt_info = vinfo_for_stmt (stmt);
--- 5265,5274 ----
  	{
  	  stmt = bsi_stmt (si);
  
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	    {
! 	      fprintf (vect_dump, "init: stmt relevant? ");
! 	      print_generic_expr (vect_dump, stmt, TDF_SLIM);
  	    } 
  
  	  stmt_info = vinfo_for_stmt (stmt);
*************** vect_mark_stmts_to_be_vectorized (loop_v
*** 5231,5240 ****
        stmt = VARRAY_TOP_TREE (worklist);
        VARRAY_POP (worklist);
  
!       if (vect_debug_details (UNKNOWN_LOC))
  	{
!           fprintf (dump_file, "worklist: examine stmt: ");
!           print_generic_expr (dump_file, stmt, TDF_SLIM);
  	}
  
        /* Examine the USES in this statement. Mark all the statements which
--- 5287,5296 ----
        stmt = VARRAY_TOP_TREE (worklist);
        VARRAY_POP (worklist);
  
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	{
!           fprintf (vect_dump, "worklist: examine stmt: ");
!           print_generic_expr (vect_dump, stmt, TDF_SLIM);
  	}
  
        /* Examine the USES in this statement. Mark all the statements which
*************** vect_mark_stmts_to_be_vectorized (loop_v
*** 5251,5268 ****
  	      basic_block bb;
  	      if (!vect_is_simple_use (arg, loop_vinfo, &def_stmt))
  		{
! 		  if (vect_debug_details (UNKNOWN_LOC))	
! 		    fprintf (dump_file, "worklist: unsupported use.");
  		  varray_clear (worklist);
  		  return false;
  		}
  	      if (!def_stmt)
  		continue;
  
! 	      if (vect_debug_details (UNKNOWN_LOC))
  	        {
! 	          fprintf (dump_file, "worklist: def_stmt: ");
! 		  print_generic_expr (dump_file, def_stmt, TDF_SLIM);
  		}
  
  	      bb = bb_for_stmt (def_stmt);
--- 5307,5329 ----
  	      basic_block bb;
  	      if (!vect_is_simple_use (arg, loop_vinfo, &def_stmt))
  		{
! 		  if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                             LOOP_LOC (loop_vinfo)))	
!                     {
!                       fprintf (vect_dump,
!                                "not vectorized: unsupported use in stmt: " );
!                       print_generic_expr (vect_dump, stmt, TDF_SLIM);
!                     }
  		  varray_clear (worklist);
  		  return false;
  		}
  	      if (!def_stmt)
  		continue;
  
! 	      if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	        {
! 	          fprintf (vect_dump, "worklist: def_stmt: ");
! 		  print_generic_expr (vect_dump, def_stmt, TDF_SLIM);
  		}
  
  	      bb = bb_for_stmt (def_stmt);
*************** vect_mark_stmts_to_be_vectorized (loop_v
*** 5287,5294 ****
                basic_block bb;
                if (!vect_is_simple_use (use, loop_vinfo, &def_stmt))
                  {
!                   if (vect_debug_details (UNKNOWN_LOC))        
!                     fprintf (dump_file, "worklist: unsupported use.");
                    varray_clear (worklist);
                    return false;
                  }
--- 5348,5360 ----
                basic_block bb;
                if (!vect_is_simple_use (use, loop_vinfo, &def_stmt))
                  {
!                   if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, 
!                                             LOOP_LOC (loop_vinfo)))
! 		    {
!                       fprintf (vect_dump, 
!                                "not vectorized: unsupported use in stmt: " );
!                       print_generic_expr (vect_dump, stmt, TDF_SLIM);
!                     }
                    varray_clear (worklist);
                    return false;
                  }
*************** vect_mark_stmts_to_be_vectorized (loop_v
*** 5296,5305 ****
  	      if (!def_stmt)
  		continue;
  
!               if (vect_debug_details (UNKNOWN_LOC))
                  {
!                   fprintf (dump_file, "worklist: examine use %d: ", i);
!                   print_generic_expr (dump_file, use, TDF_SLIM);
                  }
  
  	      bb = bb_for_stmt (def_stmt);
--- 5362,5371 ----
  	      if (!def_stmt)
  		continue;
  
!               if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
                  {
!                   fprintf (vect_dump, "worklist: examine use %d: ", i);
!                   print_generic_expr (vect_dump, use, TDF_SLIM);
                  }
  
  	      bb = bb_for_stmt (def_stmt);
*************** vect_can_advance_ivs_p (loop_vec_info lo
*** 5337,5346 ****
        tree access_fn = NULL;
        tree evolution_part;
  
!       if (vect_debug_details (UNKNOWN_LOC))
  	{
!           fprintf (dump_file, "Analyze phi: ");
!           print_generic_expr (dump_file, phi, TDF_SLIM);
  	}
  
        /* Skip virtual phi's. The data dependences that are associated with
--- 5403,5412 ----
        tree access_fn = NULL;
        tree evolution_part;
  
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	{
!           fprintf (vect_dump, "Analyze phi: ");
!           print_generic_expr (vect_dump, phi, TDF_SLIM);
  	}
  
        /* Skip virtual phi's. The data dependences that are associated with
*************** vect_can_advance_ivs_p (loop_vec_info lo
*** 5348,5355 ****
  
        if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
  	{
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "virtual phi. skip.");
  	  continue;
  	}
  
--- 5414,5421 ----
  
        if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
  	{
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "virtual phi. skip.");
  	  continue;
  	}
  
*************** vect_can_advance_ivs_p (loop_vec_info lo
*** 5360,5374 ****
  
        if (!access_fn)
  	{
! 	  if (vect_debug_details (UNKNOWN_LOC))
! 	    fprintf (dump_file, "No Access function.");
  	  return false;
  	}
  
!       if (vect_debug_details (UNKNOWN_LOC))
          {
! 	  fprintf (dump_file, "Access function of PHI: ");
! 	  print_generic_expr (dump_file, access_fn, TDF_SLIM);
          }
  
        evolution_part = evolution_part_in_loop_num (access_fn, loop->num);
--- 5426,5440 ----
  
        if (!access_fn)
  	{
! 	  if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	    fprintf (vect_dump, "No Access function.");
  	  return false;
  	}
  
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
          {
! 	  fprintf (vect_dump, "Access function of PHI: ");
! 	  print_generic_expr (vect_dump, access_fn, TDF_SLIM);
          }
  
        evolution_part = evolution_part_in_loop_num (access_fn, loop->num);
*************** vect_get_loop_niters (struct loop *loop,
*** 5399,5406 ****
  {
    tree niters;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<get_loop_niters>>\n");
  
    niters = number_of_iterations_in_loop (loop);
  
--- 5465,5472 ----
  {
    tree niters;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n== get_loop_niters ==\n");
  
    niters = number_of_iterations_in_loop (loop);
  
*************** vect_get_loop_niters (struct loop *loop,
*** 5409,5418 ****
      {
        *number_of_iterations = niters;
  
!       if (vect_debug_details (UNKNOWN_LOC))
  	{
! 	  fprintf (dump_file, "==> get_loop_niters:" );
! 	  print_generic_expr (dump_file, *number_of_iterations, TDF_SLIM);
  	}
      }
  
--- 5475,5484 ----
      {
        *number_of_iterations = niters;
  
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
  	{
! 	  fprintf (vect_dump, "==> get_loop_niters:" );
! 	  print_generic_expr (vect_dump, *number_of_iterations, TDF_SLIM);
  	}
      }
  
*************** vect_analyze_loop_form (struct loop *loo
*** 5441,5468 ****
    
    loop_loc = find_loop_location (loop);
  
!   if (vect_debug_details (loop_loc))
!     fprintf (dump_file, "\n<<vect_analyze_loop_form>>\n");
  
!   if (loop->inner
!       || !loop->single_exit
        || loop->num_nodes != 2
        || EDGE_COUNT (loop->header->preds) != 2
        || loop->num_entries != 1)
      {
!       if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc))
          {
!           fprintf (dump_file, "not vectorized: bad loop form. ");
!           if (loop->inner)
!             fprintf (dump_file, "nested loop.");
!           else if (!loop->single_exit)
!             fprintf (dump_file, "multiple exits.");
            else if (loop->num_nodes != 2)
!             fprintf (dump_file, "too many BBs in loop.");
            else if (EDGE_COUNT (loop->header->preds) != 2)
!             fprintf (dump_file, "too many incoming edges.");
            else if (loop->num_entries != 1)
!             fprintf (dump_file, "too many entries.");
          }
  
        return NULL;
--- 5507,5537 ----
    
    loop_loc = find_loop_location (loop);
  
!   if (vect_print_dump_info (REPORT_DETAILS, loop_loc))
!     fprintf (vect_dump, "\n== vect_analyze_loop_form ==\n");
  
!   if (loop->inner)
!     {
!       if (vect_print_dump_info (REPORT_OUTER_LOOPS, loop_loc))
!         fprintf (vect_dump, "not vectorized: nested loop.");
!       return NULL; 
!     }
! 
!   if (!loop->single_exit
        || loop->num_nodes != 2
        || EDGE_COUNT (loop->header->preds) != 2
        || loop->num_entries != 1)
      {
!       if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
          {
!           if (!loop->single_exit)
!             fprintf (vect_dump, "not vectorized: multiple exits.");
            else if (loop->num_nodes != 2)
!             fprintf (vect_dump, "not vectorized: too many BBs in loop.");
            else if (EDGE_COUNT (loop->header->preds) != 2)
!             fprintf (vect_dump, "not vectorized: too many incoming edges.");
            else if (loop->num_entries != 1)
!             fprintf (vect_dump, "not vectorized: too many entries.");
          }
  
        return NULL;
*************** vect_analyze_loop_form (struct loop *loo
*** 5474,5481 ****
       executable statements, and the latch is empty.  */
    if (!empty_block_p (loop->latch))
      {
!       if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc))
!         fprintf (dump_file, "not vectorized: unexpectd loop form.");
        return NULL;
      }
  
--- 5543,5550 ----
       executable statements, and the latch is empty.  */
    if (!empty_block_p (loop->latch))
      {
!       if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
!         fprintf (vect_dump, "not vectorized: unexpectd loop form.");
        return NULL;
      }
  
*************** vect_analyze_loop_form (struct loop *loo
*** 5502,5532 ****
  
    if (empty_block_p (loop->header))
      {
!       if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc))
!         fprintf (dump_file, "not vectorized: empty loop.");
        return NULL;
      }
  
    loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
    if (!loop_cond)
      {
!       if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc))
!         fprintf (dump_file, "not vectorized: complicated exit condition.");
        return NULL;
      }
  
    if (!number_of_iterations)
      {
!       if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc))
!         fprintf (dump_file,
                   "not vectorized: number of iterations cannot be computed.");
        return NULL;
      }
  
    if (chrec_contains_undetermined (number_of_iterations))
      {
!       if (vect_debug_details (loop_loc))
!         fprintf (dump_file, "Infinite number of iterations.");
        return false;
      }
  
--- 5571,5601 ----
  
    if (empty_block_p (loop->header))
      {
!       if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
!         fprintf (vect_dump, "not vectorized: empty loop.");
        return NULL;
      }
  
    loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
    if (!loop_cond)
      {
!       if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
!         fprintf (vect_dump, "not vectorized: complicated exit condition.");
        return NULL;
      }
  
    if (!number_of_iterations)
      {
!       if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
!         fprintf (vect_dump,
                   "not vectorized: number of iterations cannot be computed.");
        return NULL;
      }
  
    if (chrec_contains_undetermined (number_of_iterations))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, loop_loc))
!         fprintf (vect_dump, "Infinite number of iterations.");
        return false;
      }
  
*************** vect_analyze_loop_form (struct loop *loo
*** 5535,5552 ****
  
    if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
      {
!       if (vect_debug_details (loop_loc))
          {
!           fprintf (dump_file, "loop bound unknown.\n");
!           fprintf (dump_file, "Symbolic number of iterations is ");
!           print_generic_expr (dump_file, number_of_iterations, TDF_DETAILS);
          }
      }
    else
    if (LOOP_VINFO_INT_NITERS (loop_vinfo) == 0)
      {
!       if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc))
!         fprintf (dump_file, "not vectorized: number of iterations = 0.");
        return NULL;
      }
  
--- 5604,5621 ----
  
    if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
      {
!       if (vect_print_dump_info (REPORT_DETAILS, loop_loc))
          {
!           fprintf (vect_dump, "loop bound unknown.\n");
!           fprintf (vect_dump, "Symbolic number of iterations is ");
!           print_generic_expr (vect_dump, number_of_iterations, TDF_DETAILS);
          }
      }
    else
    if (LOOP_VINFO_INT_NITERS (loop_vinfo) == 0)
      {
!       if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, loop_loc))
!         fprintf (vect_dump, "not vectorized: number of iterations = 0.");
        return NULL;
      }
  
*************** vect_analyze_loop (struct loop *loop)
*** 5569,5584 ****
    bool ok;
    loop_vec_info loop_vinfo;
  
!   if (vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\n<<<<<<< analyze_loop_nest >>>>>>>\n");
  
    /* Check the CFG characteristics of the loop (nesting, entry/exit, etc.  */
  
    loop_vinfo = vect_analyze_loop_form (loop);
    if (!loop_vinfo)
      {
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "bad loop form.");
        return NULL;
      }
  
--- 5638,5653 ----
    bool ok;
    loop_vec_info loop_vinfo;
  
!   if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\n==== analyze_loop_nest ====\n");
  
    /* Check the CFG characteristics of the loop (nesting, entry/exit, etc.  */
  
    loop_vinfo = vect_analyze_loop_form (loop);
    if (!loop_vinfo)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "bad loop form.");
        return NULL;
      }
  
*************** vect_analyze_loop (struct loop *loop)
*** 5591,5598 ****
    ok = vect_analyze_data_refs (loop_vinfo);
    if (!ok)
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "bad data references.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
--- 5660,5667 ----
    ok = vect_analyze_data_refs (loop_vinfo);
    if (!ok)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "bad data references.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
*************** vect_analyze_loop (struct loop *loop)
*** 5602,5611 ****
    ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
    if (!ok)
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "unexpected pattern.");
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "not vectorized: unexpected pattern.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
--- 5671,5678 ----
    ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
    if (!ok)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "unexpected pattern.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
*************** vect_analyze_loop (struct loop *loop)
*** 5616,5623 ****
    ok = vect_analyze_scalar_cycles (loop_vinfo);
    if (!ok)
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "bad scalar cycle.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
--- 5683,5690 ----
    ok = vect_analyze_scalar_cycles (loop_vinfo);
    if (!ok)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "bad scalar cycle.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
*************** vect_analyze_loop (struct loop *loop)
*** 5628,5635 ****
    ok = vect_analyze_data_ref_dependences (loop_vinfo);
    if (!ok)
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "bad data dependence.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
--- 5695,5702 ----
    ok = vect_analyze_data_ref_dependences (loop_vinfo);
    if (!ok)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "bad data dependence.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
*************** vect_analyze_loop (struct loop *loop)
*** 5640,5647 ****
    ok = vect_analyze_data_ref_accesses (loop_vinfo);
    if (!ok)
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "bad data access.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
--- 5707,5714 ----
    ok = vect_analyze_data_ref_accesses (loop_vinfo);
    if (!ok)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "bad data access.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
*************** vect_analyze_loop (struct loop *loop)
*** 5652,5659 ****
    ok = vect_analyze_data_refs_alignment (loop_vinfo);
    if (!ok)
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "bad data alignment.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
--- 5719,5726 ----
    ok = vect_analyze_data_refs_alignment (loop_vinfo);
    if (!ok)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "bad data alignment.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
*************** vect_analyze_loop (struct loop *loop)
*** 5664,5671 ****
    ok = vect_analyze_operations (loop_vinfo);
    if (!ok)
      {
!       if (vect_debug_details (LOOP_LOC (loop_vinfo)))
! 	fprintf (dump_file, "bad operation or unsupported loop bound.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
--- 5731,5738 ----
    ok = vect_analyze_operations (loop_vinfo);
    if (!ok)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
! 	fprintf (vect_dump, "bad operation or unsupported loop bound.");
        destroy_loop_vec_info (loop_vinfo);
        return NULL;
      }
*************** vectorize_loops (struct loops *loops)
*** 5699,5710 ****
    unsigned int i, loops_num;
    unsigned int num_vectorized_loops = 0;
  
    /* Does the target support SIMD?  */
    /* FORNOW: until more sophisticated machine modelling is in place.  */
    if (!UNITS_PER_SIMD_WORD)
      {
!       if (vect_debug_details (UNKNOWN_LOC))
! 	fprintf (dump_file, "vectorizer: target vector size is not defined.");
        return;
      }
  
--- 5766,5780 ----
    unsigned int i, loops_num;
    unsigned int num_vectorized_loops = 0;
  
+   /* Fix the verbosity level if not defined explicitly by the user.  */
+   vect_set_dump_settings ();
+ 
    /* Does the target support SIMD?  */
    /* FORNOW: until more sophisticated machine modelling is in place.  */
    if (!UNITS_PER_SIMD_WORD)
      {
!       if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
! 	fprintf (vect_dump, "vectorizer: target vector size is not defined.");
        return;
      }
  
*************** vectorize_loops (struct loops *loops)
*** 5738,5745 ****
        num_vectorized_loops++;
      }
  
!   if (vect_debug_stats (UNKNOWN_LOC) || vect_debug_details (UNKNOWN_LOC))
!     fprintf (dump_file, "\nvectorized %u loops in function.\n",
  	     num_vectorized_loops);
  
    /*  ----------- Finalize. -----------  */
--- 5808,5815 ----
        num_vectorized_loops++;
      }
  
!   if (vect_print_dump_info (REPORT_VECTORIZED_LOOPS, UNKNOWN_LOC))
!     fprintf (vect_dump, "\nvectorized %u loops in function.\n",
  	     num_vectorized_loops);
  
    /*  ----------- Finalize. -----------  */
*** tree-vectorizer.h	2005-01-19 17:40:16.000000000 -0800
--- tree-vectorizer.h.Jan19.1945	2005-01-19 17:39:15.000000000 -0800
*************** enum dr_alignment_support {
*** 56,61 ****
--- 56,74 ----
    dr_aligned
  };
  
+ /* Define verbosity levels.  */
+ enum verbosity_levels {
+   REPORT_NONE,
+   REPORT_VECTORIZED_LOOPS,
+   REPORT_UNVECTORIZED_LOOPS,
+   REPORT_ALIGNMENT,
+   REPORT_BAD_FORM_LOOPS,
+   REPORT_OUTER_LOOPS,
+   REPORT_DETAILS,
+   /* New verbosity levels should be added before this one.  */
+   MAX_VERBOSITY_LEVEL
+ };
+ 
  /*-----------------------------------------------------------------*/
  /* Info on vectorized loops.                                       */
  /*-----------------------------------------------------------------*/
*** opts.c	2005-01-16 08:10:01.000000000 -0800
--- opts.c.Jan19.1000	2005-01-19 08:02:52.000000000 -0800
*************** common_handle_option (size_t scode, cons
*** 942,947 ****
--- 942,951 ----
        stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
        break;
  
+     case OPT_ftree_vectorizer_verbose_:
+       vect_set_verbosity_level (arg);
+       break;
+ 
      case OPT_ftls_model_:
        if (!strcmp (arg, "global-dynamic"))
  	flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
*** common.opt	2005-01-16 08:07:32.000000000 -0800
--- common.opt.Jan19.1000	2005-01-19 08:03:06.000000000 -0800
*************** ftree-vectorize
*** 920,925 ****
--- 920,929 ----
  Common Report Var(flag_tree_vectorize)
  Enable loop vectorization on trees
  
+ ftree-vectorizer-verbose=
+ Common RejectNegative Joined
+ -ftree-vectorizer-verbose=<number>   Set the verbosity level of the vectorizer
+ 
  ; -fverbose-asm causes extra commentary information to be produced in
  ; the generated assembly code (to make it more readable).  This option
  ; is generally only of use to those who actually need to read the
*** tree.h	2005-01-16 08:14:04.000000000 -0800
--- tree.h.Jan19.1000	2005-01-19 08:02:36.000000000 -0800
*************** extern bool thread_through_all_blocks (v
*** 3911,3914 ****
--- 3911,3917 ----
  /* In tree-gimple.c.  */
  extern tree get_base_address (tree t);
  
+ /* In tree-vectorizer.c.  */
+ extern void vect_set_verbosity_level (const char *);
+ 
  #endif  /* GCC_TREE_H  */
*** invoke.texi 19 Dec 2004 23:24:58 -0000      1.557.2.2
--- invoke.texi 19 Jan 2005 16:04:30 -0000
*************** Objective-C and Objective-C++ Dialects}.
*** 267,272 ****
--- 267,273 ----
  -fdump-tree-nrv -fdump-tree-vect @gol
  -fdump-tree-sra@r{[}-@var{n}@r{]} @gol
  -fdump-tree-fre@r{[}-@var{n}@r{]} @gol
+ -ftree-vectorizer-verbose=@var{n} @gol
  -feliminate-dwarf2-dups -feliminate-unused-debug-types @gol
  -feliminate-unused-debug-symbols -fmem-report -fprofile-arcs -ftree-based-profiling @gol
  -frandom-seed=@var{string} -fsched-verbose=@var{n} @gol
*************** made by appending @file{.vect} to the so
*** 3852,3857 ****
--- 3853,3865 ----
  Enable all the available tree dumps with the flags provided in this option.
  @end table

+ @item -ftree-vectorizer-verbose=@var{n}
+ @opindex ftree-vectorizer-verbose
+ This option controls the amount of debugging output the vectorizer prints.
+ This information is written to standard error, unless @option{-fdump-tree-all} 
+ or @option{-fdump-tree-vect} is specified, in which case it is output to the
+ usual dump listing file, @file{.vect}.
+
  @item -frandom-seed=@var{string}
  @opindex frandom-string
  This option provides a seed that GCC uses when it would otherwise use
*** vect.exp	3 Jan 2005 19:59:13 -0000	1.6
--- vect.exp	19 Jan 2005 19:09:19 -0000
*************** load_lib gcc-dg.exp
*** 23,29 ****
  set DEFAULT_VECTCFLAGS ""
  
  # These flags are used for all targets.
! lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" "-fdump-tree-vect-stats"
  
  # If the target system supports vector instructions, the default action
  # for a test is 'run', otherwise it's 'compile'.  Save current default.
--- 23,30 ----
  set DEFAULT_VECTCFLAGS ""
  
  # These flags are used for all targets.
! lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" \
!   "-ftree-vectorizer-verbose=3" "-fdump-tree-vect-stats"
  
  # If the target system supports vector instructions, the default action
  # for a test is 'run', otherwise it's 'compile'.  Save current default.