[patch] Rename force_vect into force_vectorize

[Eric Botcazou <ebotcazou at adacore dot com>]

Hi,

the 'loop' structure in cfgloop.h contains two consecutive fields:

   /* True if we should try harder to vectorize this loop.  */
   bool force_vect;
 
   /* True if this loop should never be vectorized.  */
   bool dont_vectorize;

Not clear why someone thought that the name discrepancy would be helpful so 
this patch standardizes the spelling (in favor of 'vectorize', as in the long 
existing flag_tree_loop_vectorize switch).

Tested on x86_64-suse-linux,  OK for the mainline?


2014-04-14  Eric Botcazou  <ebotcazou@adacore.com>

	* cfgloop.h (struct loop): Rename force_vect into force_vectorize.
	* function.h (struct function): Rename has_force_vect_loops into
	has_force_vectorize_loops.
	* lto-streamer-in.c (input_cfg): Adjust for renaming.
	(input_struct_function_base): Likewise.
	* lto-streamer-out.c (output_cfg): Likewise.
	(output_struct_function_base): Likewise.
	* omp-low.c (expand_omp_simd): Likewise.
	* tree-cfg.c (move_sese_region_to_fn): Likewise.
	* tree-if-conv.c (ifcvt_can_use_mask_load_store): Likewise.
	(version_loop_for_if_conversion): Likewise.
	(tree_if_conversion): Likewise.
	(main_tree_if_conversion): Likewise.
	(gate_tree_if_conversion): Likewise.
	* tree-inline.c (copy_loops): Likewise.
	* tree-ssa-loop-ivcanon.c (tree_unroll_loops_completely_1): Likewise.
	* tree-ssa-loop.c (tree_loop_vectorize): Likewise.
	* tree-ssa-phiopt.c (tree_ssa_phiopt_worker): Likewise.
	* tree-vect-loop.c (vect_estimate_min_profitable_iters): Likewise.
	* tree-vectorizer.c (vectorize_loops): Likewise.
	* tree-vectorizer.h (unlimited_cost_model): Likewise.


-- 
Eric Botcazou

Index: omp-low.c
===================================================================
--- omp-low.c	(revision 209334)
+++ omp-low.c	(working copy)
@@ -6843,8 +6843,8 @@ expand_omp_simd (struct omp_region *regi
 	  && flag_tree_loop_optimize
 	  && loop->safelen > 1)
 	{
-	  loop->force_vect = true;
-	  cfun->has_force_vect_loops = true;
+	  loop->force_vectorize = true;
+	  cfun->has_force_vectorize_loops = true;
 	}
     }
 }
@@ -11487,9 +11487,9 @@ simd_clone_adjust (struct cgraph_node *n
 
   /* Mostly annotate the loop for the vectorizer (the rest is done below).  */
   struct loop *loop = alloc_loop ();
-  cfun->has_force_vect_loops = true;
+  cfun->has_force_vectorize_loops = true;
   loop->safelen = node->simdclone->simdlen;
-  loop->force_vect = true;
+  loop->force_vectorize = true;
   loop->header = body_bb;
   add_bb_to_loop (incr_bb, loop);
 
Index: lto-streamer-out.c
===================================================================
--- lto-streamer-out.c	(revision 209334)
+++ lto-streamer-out.c	(working copy)
@@ -1693,7 +1693,7 @@ output_cfg (struct output_block *ob, str
 
       /* Write OMP SIMD related info.  */
       streamer_write_hwi (ob, loop->safelen);
-      streamer_write_hwi (ob, loop->force_vect);
+      streamer_write_hwi (ob, loop->force_vectorize);
       stream_write_tree (ob, loop->simduid, true);
     }
 
@@ -1788,7 +1788,7 @@ output_struct_function_base (struct outp
   bp_pack_value (&bp, fn->has_nonlocal_label, 1);
   bp_pack_value (&bp, fn->calls_alloca, 1);
   bp_pack_value (&bp, fn->calls_setjmp, 1);
-  bp_pack_value (&bp, fn->has_force_vect_loops, 1);
+  bp_pack_value (&bp, fn->has_force_vectorize_loops, 1);
   bp_pack_value (&bp, fn->has_simduid_loops, 1);
   bp_pack_value (&bp, fn->va_list_fpr_size, 8);
   bp_pack_value (&bp, fn->va_list_gpr_size, 8);
Index: tree-ssa-loop-ivcanon.c
===================================================================
--- tree-ssa-loop-ivcanon.c	(revision 209334)
+++ tree-ssa-loop-ivcanon.c	(working copy)
@@ -1129,7 +1129,7 @@ tree_unroll_loops_completely_1 (bool may
 
   /* Don't unroll #pragma omp simd loops until the vectorizer
      attempts to vectorize those.  */
-  if (loop->force_vect)
+  if (loop->force_vectorize)
     return false;
 
   /* Try to unroll this loop.  */
Index: tree-ssa-loop.c
===================================================================
--- tree-ssa-loop.c	(revision 209334)
+++ tree-ssa-loop.c	(working copy)
@@ -157,7 +157,7 @@ tree_loop_vectorize (void)
 static bool
 gate_tree_loop_vectorize (void)
 {
-  return flag_tree_loop_vectorize || cfun->has_force_vect_loops;
+  return flag_tree_loop_vectorize || cfun->has_force_vectorize_loops;
 }
 
 namespace {
Index: lto-streamer-in.c
===================================================================
--- lto-streamer-in.c	(revision 209334)
+++ lto-streamer-in.c	(working copy)
@@ -718,7 +718,7 @@ input_cfg (struct lto_input_block *ib, s
 
       /* Read OMP SIMD related info.  */
       loop->safelen = streamer_read_hwi (ib);
-      loop->force_vect = streamer_read_hwi (ib);
+      loop->force_vectorize = streamer_read_hwi (ib);
       loop->simduid = stream_read_tree (ib, data_in);
 
       place_new_loop (fn, loop);
@@ -884,7 +884,7 @@ input_struct_function_base (struct funct
   fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
   fn->calls_alloca = bp_unpack_value (&bp, 1);
   fn->calls_setjmp = bp_unpack_value (&bp, 1);
-  fn->has_force_vect_loops = bp_unpack_value (&bp, 1);
+  fn->has_force_vectorize_loops = bp_unpack_value (&bp, 1);
   fn->has_simduid_loops = bp_unpack_value (&bp, 1);
   fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
   fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
Index: tree-vectorizer.c
===================================================================
--- tree-vectorizer.c	(revision 209334)
+++ tree-vectorizer.c	(working copy)
@@ -417,7 +417,7 @@ vectorize_loops (void)
       any_ifcvt_loops = true;
     else if ((flag_tree_loop_vectorize
 	      && optimize_loop_nest_for_speed_p (loop))
-	     || loop->force_vect)
+	     || loop->force_vectorize)
       {
 	loop_vec_info loop_vinfo;
 	vect_location = find_loop_location (loop);
@@ -477,7 +477,7 @@ vectorize_loops (void)
 	num_vectorized_loops++;
 	/* Now that the loop has been vectorized, allow it to be unrolled
 	   etc.  */
-	loop->force_vect = false;
+	loop->force_vectorize = false;
 
 	if (loop->simduid)
 	  {
Index: function.h
===================================================================
--- function.h	(revision 209334)
+++ function.h	(working copy)
@@ -661,8 +661,8 @@ struct GTY(()) function {
   unsigned int is_thunk : 1;
 
   /* Nonzero if the current function contains any loops with
-     loop->force_vect set.  */
-  unsigned int has_force_vect_loops : 1;
+     loop->force_vectorize set.  */
+  unsigned int has_force_vectorize_loops : 1;
 
   /* Nonzero if the current function contains any loops with
      nonzero value in loop->simduid.  */
Index: tree-vectorizer.h
===================================================================
--- tree-vectorizer.h	(revision 209334)
+++ tree-vectorizer.h	(working copy)
@@ -958,7 +958,7 @@ known_alignment_for_access_p (struct dat
 static inline bool
 unlimited_cost_model (loop_p loop)
 {
-  if (loop != NULL && loop->force_vect
+  if (loop != NULL && loop->force_vectorize
       && flag_simd_cost_model != VECT_COST_MODEL_DEFAULT)
     return flag_simd_cost_model == VECT_COST_MODEL_UNLIMITED;
   return (flag_vect_cost_model == VECT_COST_MODEL_UNLIMITED);
Index: tree-if-conv.c
===================================================================
--- tree-if-conv.c	(revision 209334)
+++ tree-if-conv.c	(working copy)
@@ -728,7 +728,7 @@ ifcvt_can_use_mask_load_store (gimple st
   basic_block bb = gimple_bb (stmt);
   bool is_load;
 
-  if (!(flag_tree_loop_vectorize || bb->loop_father->force_vect)
+  if (!(flag_tree_loop_vectorize || bb->loop_father->force_vectorize)
       || bb->loop_father->dont_vectorize
       || !gimple_assign_single_p (stmt)
       || gimple_has_volatile_ops (stmt))
@@ -1926,7 +1926,7 @@ version_loop_for_if_conversion (struct l
   if (new_loop == NULL)
     return false;
   new_loop->dont_vectorize = true;
-  new_loop->force_vect = false;
+  new_loop->force_vectorize = false;
   gsi = gsi_last_bb (cond_bb);
   gimple_call_set_arg (g, 1, build_int_cst (integer_type_node, new_loop->num));
   gsi_insert_before (&gsi, g, GSI_SAME_STMT);
@@ -1950,7 +1950,7 @@ tree_if_conversion (struct loop *loop)
     goto cleanup;
 
   if (any_mask_load_store
-      && ((!flag_tree_loop_vectorize && !loop->force_vect)
+      && ((!flag_tree_loop_vectorize && !loop->force_vectorize)
 	  || loop->dont_vectorize))
     goto cleanup;
 
@@ -1998,7 +1998,7 @@ main_tree_if_conversion (void)
   FOR_EACH_LOOP (loop, 0)
     if (flag_tree_loop_if_convert == 1
 	|| flag_tree_loop_if_convert_stores == 1
-	|| ((flag_tree_loop_vectorize || loop->force_vect)
+	|| ((flag_tree_loop_vectorize || loop->force_vectorize)
 	    && !loop->dont_vectorize))
       todo |= tree_if_conversion (loop);
 
@@ -2018,7 +2018,7 @@ main_tree_if_conversion (void)
 static bool
 gate_tree_if_conversion (void)
 {
-  return (((flag_tree_loop_vectorize || cfun->has_force_vect_loops)
+  return (((flag_tree_loop_vectorize || cfun->has_force_vectorize_loops)
 	   && flag_tree_loop_if_convert != 0)
 	  || flag_tree_loop_if_convert == 1
 	  || flag_tree_loop_if_convert_stores == 1);
Index: tree-vect-loop.c
===================================================================
--- tree-vect-loop.c	(revision 209334)
+++ tree-vect-loop.c	(working copy)
@@ -2986,7 +2986,7 @@ vect_estimate_min_profitable_iters (loop
   /* vector version will never be profitable.  */
   else
     {
-      if (LOOP_VINFO_LOOP (loop_vinfo)->force_vect)
+      if (LOOP_VINFO_LOOP (loop_vinfo)->force_vectorize)
 	warning_at (vect_location, OPT_Wopenmp_simd, "vectorization "
 		    "did not happen for a simd loop");
 
Index: tree-ssa-phiopt.c
===================================================================
--- tree-ssa-phiopt.c	(revision 209334)
+++ tree-ssa-phiopt.c	(working copy)
@@ -350,7 +350,7 @@ tree_ssa_phiopt_worker (bool do_store_el
   if (!do_store_elim)
     replace_conditional_negation
       = ((!optimize_size && optimize >= 2)
-	 || (((flag_tree_loop_vectorize || cfun->has_force_vect_loops)
+	 || (((flag_tree_loop_vectorize || cfun->has_force_vectorize_loops)
 	      && flag_tree_loop_if_convert != 0)
 	     || flag_tree_loop_if_convert == 1
 	     || flag_tree_loop_if_convert_stores == 1));
Index: tree-inline.c
===================================================================
--- tree-inline.c	(revision 209334)
+++ tree-inline.c	(working copy)
@@ -2354,10 +2354,10 @@ copy_loops (copy_body_data *id,
 	      dest_loop->simduid = remap_decl (src_loop->simduid, id);
 	      cfun->has_simduid_loops = true;
 	    }
-	  if (src_loop->force_vect)
+	  if (src_loop->force_vectorize)
 	    {
-	      dest_loop->force_vect = true;
-	      cfun->has_force_vect_loops = true;
+	      dest_loop->force_vectorize = true;
+	      cfun->has_force_vectorize_loops = true;
 	    }
 	  dest_loop->safelen = src_loop->safelen;
 
Index: cfgloop.h
===================================================================
--- cfgloop.h	(revision 209334)
+++ cfgloop.h	(working copy)
@@ -174,7 +174,7 @@ struct GTY ((chain_next ("%h.next"))) lo
   int safelen;
 
   /* True if we should try harder to vectorize this loop.  */
-  bool force_vect;
+  bool force_vectorize;
 
   /* True if this loop should never be vectorized.  */
   bool dont_vectorize;
Index: tree-cfg.c
===================================================================
--- tree-cfg.c	(revision 209334)
+++ tree-cfg.c	(working copy)
@@ -6967,7 +6967,7 @@ move_sese_region_to_fn (struct function
     outer->num_nodes -= num_nodes;
   loop0->num_nodes -= bbs.length () - num_nodes;
 
-  if (saved_cfun->has_simduid_loops || saved_cfun->has_force_vect_loops)
+  if (saved_cfun->has_simduid_loops || saved_cfun->has_force_vectorize_loops)
     {
       struct loop *aloop;
       for (i = 0; vec_safe_iterate (loops->larray, i, &aloop); i++)
@@ -6979,8 +6979,8 @@ move_sese_region_to_fn (struct function
 					   d.to_context);
 		dest_cfun->has_simduid_loops = true;
 	      }
-	    if (aloop->force_vect)
-	      dest_cfun->has_force_vect_loops = true;
+	    if (aloop->force_vectorize)
+	      dest_cfun->has_force_vectorize_loops = true;
 	  }
     }