diff mbox series

[v6,11/11] Add extra conditional dump output to the vectorizer

Message ID 20251206165518.5449-12-chris.bazley@arm.com
State Superseded
Headers
Series Extend BB SLP vectorization to use predicated tails |

Commit Message

Christopher Bazley Dec. 6, 2025, 4:55 p.m. UTC 
  Instruments those things that needed to be instrumented
in order to develop predicated tails for basic block
SLP (superword-level parallelism).

gcc/ChangeLog:

	* tree-vect-loop.cc (vect_get_max_nscalars_per_iter): Dump the
	result.
	(vect_verify_full_masking): Dump the number of vectors and
	number of scalars per iteration.
	* tree-vect-slp.cc (vect_prologue_cost_for_slp): Dump the SLP
	tree node's address, vector type and group size.
	* tree-vect-stmts.cc (vectorizable_conversion): Dump the vector
	type inferred from the scalar type.
	(vectorizable_comparison_1): Dump the vector type guessed for
	an invariant comparison.
	(get_vectype_for_scalar_type): Dump the natural choice of
	vector type and instrument the fallback loop which searches for
	a narrower type.
	(vect_maybe_update_slp_op_vectype): Dump the new vector type
	and number of lanes of an operand when its vector type is
	updated.

---
 gcc/tree-vect-loop.cc  | 10 ++++++++++
 gcc/tree-vect-slp.cc   |  6 ++++++
 gcc/tree-vect-stmts.cc | 38 +++++++++++++++++++++++++++++++++++++-
 3 files changed, 53 insertions(+), 1 deletion(-)
diff mbox series

Patch

diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc
index 9164cef92da..4f8c500c131 100644
--- a/gcc/tree-vect-loop.cc
+++ b/gcc/tree-vect-loop.cc
@@ -906,6 +906,11 @@  vect_get_max_nscalars_per_iter (loop_vec_info loop_vinfo)
   rgroup_controls *rgm;
   FOR_EACH_VEC_ELT (LOOP_VINFO_MASKS (loop_vinfo).rgc_vec, i, rgm)
     res = MAX (res, rgm->max_nscalars_per_iter);
+
+  if (dump_enabled_p ())
+    dump_printf_loc (MSG_NOTE, vect_location, "max_nscalars_per_iter=%u\n",
+		     res);
+
   return res;
 }
 
@@ -1018,6 +1023,11 @@  vect_verify_full_masking (loop_vec_info loop_vinfo)
       unsigned int nscalars_per_iter
 	  = exact_div (nvectors * TYPE_VECTOR_SUBPARTS (vectype),
 		       LOOP_VINFO_VECT_FACTOR (loop_vinfo)).to_constant ();
+      if (dump_enabled_p ())
+	dump_printf_loc (
+	  MSG_NOTE, vect_location,
+	  "verify_full_masking: nvectors=%u, nscalars_per_iter=%u\n", nvectors,
+	  nscalars_per_iter);
 
       if (rgm->max_nscalars_per_iter < nscalars_per_iter)
 	{
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index 4cd687a324e..bcabcb75b6c 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -8781,6 +8781,12 @@  vect_prologue_cost_for_slp (vec_info *vinfo, slp_tree node,
      When all elements are the same we can use a splat.  */
   tree vectype = SLP_TREE_VECTYPE (node);
   unsigned group_size = SLP_TREE_SCALAR_OPS (node).length ();
+  if (dump_enabled_p ())
+    dump_printf_loc (MSG_NOTE, vect_location,
+		     "vect_prologue_cost_for_slp: node %p, vector type %T, "
+		     "group_size %u\n",
+		     (void *) node, vectype, group_size);
+
   unsigned HOST_WIDE_INT const_nunits;
   unsigned nelt_limit;
   unsigned nvectors = vect_get_num_copies (vinfo, node);
diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc
index 5bd32e5f287..ce24dfa11b2 100644
--- a/gcc/tree-vect-stmts.cc
+++ b/gcc/tree-vect-stmts.cc
@@ -5474,7 +5474,12 @@  vectorizable_conversion (vec_info *vinfo,
   /* If op0 is an external or constant def, infer the vector type
      from the scalar type.  */
   if (!vectype_in)
-    vectype_in = get_vectype_for_scalar_type (vinfo, rhs_type, slp_node);
+    {
+      vectype_in = get_vectype_for_scalar_type (vinfo, rhs_type, slp_node);
+      if (dump_enabled_p ())
+	dump_printf_loc (MSG_NOTE, vect_location, "inferred vector type %T\n",
+			 vectype_in);
+    }
 
   if (!cost_vec)
     gcc_assert (vectype_in);
@@ -12628,6 +12633,16 @@  vectorizable_comparison_1 (vec_info *vinfo, tree vectype,
   if (!vectype)
     {
       vectype = get_vectype_for_scalar_type (vinfo, TREE_TYPE (rhs1), slp_node);
+      if (dump_enabled_p ())
+	{
+	  if (vectype)
+	    dump_printf_loc (MSG_NOTE, vect_location,
+			     "invariant comparison, guessed type %T\n",
+			     vectype);
+	  else
+	    dump_printf_loc (MSG_NOTE, vect_location,
+			     "invariant comparison, no usable vector type\n");
+	}
       if (!vectype || maybe_ne (TYPE_VECTOR_SUBPARTS (vectype), nunits))
 	return false;
     }
@@ -13602,7 +13617,19 @@  get_vectype_for_scalar_type (vec_info *vinfo, tree scalar_type,
   /* Register the natural choice of vector type, before the group size
      has been applied.  */
   if (vectype)
+  {
+    if (dump_enabled_p ())
+      dump_printf_loc (MSG_NOTE, vect_location,
+		       "get_vectype_for_scalar_type: natural type for %T "
+		       "(ignoring group size %u): %T\n",
+		       scalar_type, group_size, vectype);
     vinfo->used_vector_modes.add (TYPE_MODE (vectype));
+  }
+  else if (dump_enabled_p ())
+    dump_printf_loc (MSG_NOTE, vect_location,
+		     "get_vectype_for_scalar_type: no natural type for %T "
+		     "(ignoring group size %u)\n",
+		     scalar_type, group_size);
 
   /* If the natural choice of vector type doesn't satisfy GROUP_SIZE,
      try again with an explicit number of elements.  A vector type satisfies
@@ -13635,6 +13662,11 @@  get_vectype_for_scalar_type (vec_info *vinfo, tree scalar_type,
 	{
 	  vectype = get_related_vectype_for_scalar_type (vinfo->vector_mode,
 							 scalar_type, nunits);
+	  if (dump_enabled_p ())
+	    dump_printf_loc (MSG_NOTE, vect_location,
+			     "get_vectype_for_scalar_type: trying %u elements "
+			     "of type %T: %T\n",
+			     nunits, scalar_type, vectype);
 	  nunits /= 2;
 	}
       while (nunits > 1 && !vectype);
@@ -13963,6 +13995,10 @@  vect_maybe_update_slp_op_vectype (vec_info *vinfo, slp_tree op, tree vectype)
     }
 
   SLP_TREE_VECTYPE (op) = vectype;
+  if (dump_enabled_p ())
+      dump_printf_loc (MSG_NOTE, vect_location,
+		       "updated vectype of operand %p with %u lanes to %T\n",
+		       (void *) op, SLP_TREE_LANES (op), vectype);
   return true;
 }